mirror of
https://github.com/boostorg/bind.git
synced 2026-04-14 13:45:55 +02:00
Compare commits
2 Commits
boost-1.31
...
boost-1.28
| Author | SHA1 | Date | |
|---|---|---|---|
|
18f4f3e721 | ||
|
|
5cd402dcf3 |
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -32,7 +30,9 @@
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
struct X
|
||||
{
|
||||
@@ -158,8 +158,8 @@ void member_function_test()
|
||||
BOOST_TEST( x.hash == 23558 );
|
||||
}
|
||||
|
||||
int main()
|
||||
int test_main(int, char * [])
|
||||
{
|
||||
member_function_test();
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -32,7 +30,8 @@
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
//
|
||||
|
||||
@@ -104,8 +103,8 @@ void function_test()
|
||||
BOOST_TEST( bind(f_9, _1, 2, 3, 4, 5, 6, 7, 8, 9)(i) == 987654321L );
|
||||
}
|
||||
|
||||
int main()
|
||||
int test_main(int, char * [])
|
||||
{
|
||||
function_test();
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL) && !defined(__COMO__)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -32,7 +30,9 @@
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
//
|
||||
|
||||
@@ -192,31 +192,12 @@ void function_object_test()
|
||||
|
||||
#if !defined(__MWERKS__) || (__MWERKS__ > 0x2406) // Fails for this version of the compiler.
|
||||
|
||||
global_result = 0;
|
||||
bind<void>(Y(), i, _1, 9, 4)(k);
|
||||
BOOST_TEST( global_result == 4938 );
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
void function_object_test2()
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
short i(6);
|
||||
|
||||
int const k = 3;
|
||||
|
||||
BOOST_TEST( bind(type<short>(), Y(), ref(i))() == 7 );
|
||||
BOOST_TEST( bind(type<short>(), Y(), ref(i))() == 8 );
|
||||
BOOST_TEST( bind(type<int>(), Y(), i, _1)(k) == 38 );
|
||||
BOOST_TEST( bind(type<long>(), Y(), i, _1, 9)(k) == 938 );
|
||||
|
||||
global_result = 0;
|
||||
bind(type<void>(), Y(), i, _1, 9, 4)(k);
|
||||
BOOST_TEST( global_result == 4938 );
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
|
||||
@@ -504,11 +485,10 @@ void nested_bind_test()
|
||||
BOOST_TEST( (bind(fv_1, bind(f_0))(), (global_result == 17041L)) );
|
||||
}
|
||||
|
||||
int main()
|
||||
int test_main(int, char * [])
|
||||
{
|
||||
function_test();
|
||||
function_object_test();
|
||||
function_object_test2();
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
|
||||
adaptable_function_object_test();
|
||||
@@ -518,5 +498,5 @@ int main()
|
||||
member_function_void_test();
|
||||
nested_bind_test();
|
||||
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
|
||||
242
doc/ref.xml
242
doc/ref.xml
@@ -1,242 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<library name="Ref" dirname="ref" id="ref" last-revision="$Date$">
|
||||
<libraryinfo>
|
||||
<author>
|
||||
<firstname>Jaakko</firstname>
|
||||
<surname>Järvi</surname>
|
||||
</author>
|
||||
<author>
|
||||
<firstname>Peter</firstname>
|
||||
<surname>Dimov</surname>
|
||||
</author>
|
||||
<author>
|
||||
<firstname>Douglas</firstname>
|
||||
<surname>Gregor</surname>
|
||||
</author>
|
||||
<author>
|
||||
<firstname>Dave</firstname>
|
||||
<surname>Abrahams</surname>
|
||||
</author>
|
||||
|
||||
<copyright>
|
||||
<year>1999</year>
|
||||
<year>2000</year>
|
||||
<holder>Jaakko Järvi</holder>
|
||||
</copyright>
|
||||
|
||||
<copyright>
|
||||
<year>2001</year>
|
||||
<year>2002</year>
|
||||
<holder>Peter Dimov</holder>
|
||||
</copyright>
|
||||
|
||||
<copyright>
|
||||
<year>2002</year>
|
||||
<holder>David Abrahams</holder>
|
||||
</copyright>
|
||||
|
||||
<legalnotice>
|
||||
<para>Permission to copy, use, modify, sell and distribute this
|
||||
software is granted provided this copyright notice appears in
|
||||
all copies. This software is provided "as is" without express
|
||||
or implied warranty, and with no claim as to its suitability for
|
||||
any purpose.
|
||||
</para>
|
||||
</legalnotice>
|
||||
|
||||
<librarypurpose>A utility library for passing references to generic functions</librarypurpose>
|
||||
<librarycategory name="category:higher-order"/>
|
||||
</libraryinfo>
|
||||
|
||||
<title>Boost.Ref</title>
|
||||
|
||||
<section id="ref.intro">
|
||||
<title>Introduction</title>
|
||||
|
||||
<using-namespace name="boost"/>
|
||||
|
||||
<para>The Ref library is a small library that is useful for passing
|
||||
references to function templates (algorithms) that would usually
|
||||
take copies of their arguments. It defines the class template
|
||||
<code><classname>boost::reference_wrapper<T></classname></code>,
|
||||
the two functions
|
||||
<code><functionname>boost::ref</functionname></code> and
|
||||
<code><functionname>boost::cref</functionname></code> that return
|
||||
instances of <code>boost::reference_wrapper<T></code>, and the
|
||||
two traits classes
|
||||
<code><classname>boost::is_reference_wrapper<T></classname></code>
|
||||
and
|
||||
<code><classname>boost::unwrap_reference<T></classname></code>.</para>
|
||||
|
||||
<para>The purpose of
|
||||
<code>boost::reference_wrapper<T></code> is to
|
||||
contain a reference to an object of type T. It is primarily used to
|
||||
"feed" references to function templates (algorithms) that take their
|
||||
parameter by value.</para>
|
||||
|
||||
<para>To support this usage,
|
||||
<code>boost::reference_wrapper<T></code> provides an implicit
|
||||
conversion to <code>T&</code>. This usually allows the function
|
||||
templates to work on references unmodified.</para>
|
||||
|
||||
<para><code>boost::reference_wrapper<T></code> is
|
||||
both CopyConstructible and Assignable (ordinary references are not
|
||||
Assignable).</para>
|
||||
|
||||
<para>The expression <code>boost::ref(x)</code>
|
||||
returns a
|
||||
<code>boost::reference_wrapper<X>(x)</code> where X
|
||||
is the type of x. Similarly,
|
||||
<code>boost::cref(x)</code> returns a
|
||||
<code>boost::reference_wrapper<X const>(x)</code>.</para>
|
||||
|
||||
<para>The expression
|
||||
<code>boost::is_reference_wrapper<T>::value</code>
|
||||
is true if T is a <code>reference_wrapper</code>, and
|
||||
false otherwise.</para>
|
||||
|
||||
<para>The type-expression
|
||||
<code>boost::unwrap_reference<T>::type</code> is T::type if T
|
||||
is a <code>reference_wrapper</code>, T otherwise.</para>
|
||||
</section>
|
||||
|
||||
<library-reference>
|
||||
<header name="boost/ref.hpp">
|
||||
<namespace name="boost">
|
||||
<class name="reference_wrapper">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
</template>
|
||||
<purpose>
|
||||
Contains a reference to an object of type
|
||||
<computeroutput>T</computeroutput>.
|
||||
</purpose>
|
||||
|
||||
<description>
|
||||
<para><computeroutput><classname>reference_wrapper</classname></computeroutput>
|
||||
is primarily used to "feed" references to function templates
|
||||
(algorithms) that take their parameter by value. It provides
|
||||
an implicit conversion to
|
||||
<computeroutput>T&</computeroutput>, which usually allows
|
||||
the function templates to work on references
|
||||
unmodified.</para>
|
||||
</description>
|
||||
|
||||
<typedef name="type"><type>T</type></typedef>
|
||||
|
||||
<constructor specifiers="explicit">
|
||||
<parameter name="t">
|
||||
<paramtype>T&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<effects><simpara>Constructs a
|
||||
<computeroutput><classname>reference_wrapper</classname></computeroutput>
|
||||
object that stores a reference to
|
||||
<computeroutput>t</computeroutput>.</simpara></effects>
|
||||
|
||||
<throws><simpara>Does not throw.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<method-group name="access">
|
||||
<method name="conversion-operator" cv="const">
|
||||
<type>T&</type>
|
||||
<returns><simpara>The stored reference.</simpara></returns>
|
||||
<throws><simpara>Does not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="get" cv="const">
|
||||
<type>T&</type>
|
||||
<returns><simpara>The stored reference.</simpara></returns>
|
||||
<throws><simpara>Does not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="get_pointer" cv="const">
|
||||
<type>T*</type>
|
||||
<returns><simpara>A pointer to the object referenced by the stored reference.</simpara></returns>
|
||||
<throws><simpara>Does not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<free-function-group name="constructors">
|
||||
<function name="ref">
|
||||
<type>reference_wrapper<T></type>
|
||||
<parameter name="t">
|
||||
<paramtype>T&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<returns><simpara><computeroutput><classname>reference_wrapper</classname><T>(t)</computeroutput></simpara></returns>
|
||||
|
||||
<throws><simpara>Does not throw.</simpara></throws>
|
||||
</function>
|
||||
|
||||
<function name="cref">
|
||||
<type>reference_wrapper<T const></type>
|
||||
<parameter name="t">
|
||||
<paramtype>T const&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<returns><simpara><computeroutput><classname>reference_wrapper</classname><T const>(t)</computeroutput></simpara></returns>
|
||||
|
||||
<throws><simpara>Does not throw.</simpara></throws>
|
||||
</function>
|
||||
</free-function-group>
|
||||
</class>
|
||||
|
||||
<class name="is_reference_wrapper">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
</template>
|
||||
|
||||
<purpose>Determine if a type <computeroutput>T</computeroutput> is an instantiation of <computeroutput><classname>reference_wrapper</classname></computeroutput>.</purpose>
|
||||
|
||||
<description>
|
||||
<para>The <computeroutput>value</computeroutput> static
|
||||
constant will be <computeroutput>true</computeroutput> iff the
|
||||
type <computeroutput>T</computeroutput> is a specialization of
|
||||
<computeroutput><classname>reference_wrapper</classname></computeroutput>.</para>
|
||||
</description>
|
||||
|
||||
<static-constant name="value">
|
||||
<type>bool</type>
|
||||
<default><emphasis>unspecified</emphasis></default>
|
||||
</static-constant>
|
||||
</class>
|
||||
|
||||
<class name="unwrap_reference">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
</template>
|
||||
|
||||
<purpose>Find the type in a <computeroutput><classname>reference_wrapper</classname></computeroutput>.</purpose>
|
||||
|
||||
<description>
|
||||
<para>The typedef <computeroutput>type</computeroutput> is
|
||||
<computeroutput>T::type</computeroutput> if
|
||||
<computeroutput>T</computeroutput> is a
|
||||
<computeroutput><classname>reference_wrapper</classname></computeroutput>,
|
||||
<computeroutput>T</computeroutput> otherwise.</para>
|
||||
</description>
|
||||
|
||||
<typedef name="T"><type><emphasis>unspecified</emphasis></type></typedef>
|
||||
</class>
|
||||
</namespace>
|
||||
</header>
|
||||
</library-reference>
|
||||
|
||||
<section id="ref.ack">
|
||||
<title>Acknowledgements</title>
|
||||
|
||||
<using-namespace name="boost"/>
|
||||
|
||||
<para><functionname>ref</functionname> and <functionname>cref</functionname>
|
||||
were originally part of the <libraryname>Tuple</libraryname> library
|
||||
by Jaakko Järvi. They were "promoted to boost:: status" by
|
||||
Peter Dimov because they are generally useful. Douglas Gregor and
|
||||
Dave Abrahams contributed
|
||||
<classname>is_reference_wrapper</classname> and
|
||||
<classname>unwrap_reference</classname>.</para>
|
||||
</section>
|
||||
|
||||
</library>
|
||||
@@ -1,10 +1,8 @@
|
||||
#ifndef BOOST_BIND_HPP_INCLUDED
|
||||
#define BOOST_BIND_HPP_INCLUDED
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#if _MSC_VER >= 1020
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
//
|
||||
@@ -24,7 +22,6 @@
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/mem_fn.hpp>
|
||||
#include <boost/type.hpp>
|
||||
#include <boost/bind/arg.hpp>
|
||||
|
||||
// Borland-specific bug, visit_each() silently fails to produce code
|
||||
@@ -62,11 +59,6 @@ template<class F> struct result_traits<unspecified, F>
|
||||
typedef typename F::result_type type;
|
||||
};
|
||||
|
||||
template<class F> struct result_traits< unspecified, reference_wrapper<F> >
|
||||
{
|
||||
typedef typename F::result_type type;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
// bind_t forward declaration for listN
|
||||
@@ -93,23 +85,6 @@ private:
|
||||
|
||||
template<class T> class type {};
|
||||
|
||||
// unwrap
|
||||
|
||||
template<class F> inline F & unwrap(F & f, long)
|
||||
{
|
||||
return f;
|
||||
}
|
||||
|
||||
template<class F> inline F & unwrap(reference_wrapper<F> & f, int)
|
||||
{
|
||||
return f;
|
||||
}
|
||||
|
||||
template<class F> inline F & unwrap(reference_wrapper<F> const & f, int)
|
||||
{
|
||||
return f;
|
||||
}
|
||||
|
||||
// listN
|
||||
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
@@ -143,14 +118,9 @@ public:
|
||||
|
||||
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A &)
|
||||
{
|
||||
return unwrap(f, 0)();
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A &) const
|
||||
{
|
||||
return unwrap(f, 0)();
|
||||
return f();
|
||||
}
|
||||
|
||||
template<class V> void accept(V &) const
|
||||
@@ -174,9 +144,9 @@ public:
|
||||
|
||||
explicit list1(A1 a1): a1_(a1) {}
|
||||
|
||||
A1 operator[] (boost::arg<1>) const { return a1_; }
|
||||
A1 operator[] (arg<1>) const { return a1_; }
|
||||
|
||||
A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
|
||||
A1 operator[] (arg<1> (*) ()) const { return a1_; }
|
||||
|
||||
template<class T> T & operator[] (value<T> & v) const { return v.get(); }
|
||||
|
||||
@@ -188,14 +158,9 @@ public:
|
||||
|
||||
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_]);
|
||||
return f(a[a1_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -225,11 +190,11 @@ public:
|
||||
|
||||
list2(A1 a1, A2 a2): a1_(a1), a2_(a2) {}
|
||||
|
||||
A1 operator[] (boost::arg<1>) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2>) const { return a2_; }
|
||||
A1 operator[] (arg<1>) const { return a1_; }
|
||||
A2 operator[] (arg<2>) const { return a2_; }
|
||||
|
||||
A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
|
||||
A1 operator[] (arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (arg<2> (*) ()) const { return a2_; }
|
||||
|
||||
template<class T> T & operator[] (value<T> & v) const { return v.get(); }
|
||||
|
||||
@@ -241,14 +206,9 @@ public:
|
||||
|
||||
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_]);
|
||||
return f(a[a1_], a[a2_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -280,13 +240,13 @@ public:
|
||||
|
||||
list3(A1 a1, A2 a2, A3 a3): a1_(a1), a2_(a2), a3_(a3) {}
|
||||
|
||||
A1 operator[] (boost::arg<1>) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2>) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3>) const { return a3_; }
|
||||
A1 operator[] (arg<1>) const { return a1_; }
|
||||
A2 operator[] (arg<2>) const { return a2_; }
|
||||
A3 operator[] (arg<3>) const { return a3_; }
|
||||
|
||||
A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
|
||||
A1 operator[] (arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (arg<3> (*) ()) const { return a3_; }
|
||||
|
||||
template<class T> T & operator[] (value<T> & v) const { return v.get(); }
|
||||
|
||||
@@ -298,14 +258,9 @@ public:
|
||||
|
||||
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
|
||||
return f(a[a1_], a[a2_], a[a3_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -339,15 +294,15 @@ public:
|
||||
|
||||
list4(A1 a1, A2 a2, A3 a3, A4 a4): a1_(a1), a2_(a2), a3_(a3), a4_(a4) {}
|
||||
|
||||
A1 operator[] (boost::arg<1>) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2>) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3>) const { return a3_; }
|
||||
A4 operator[] (boost::arg<4>) const { return a4_; }
|
||||
A1 operator[] (arg<1>) const { return a1_; }
|
||||
A2 operator[] (arg<2>) const { return a2_; }
|
||||
A3 operator[] (arg<3>) const { return a3_; }
|
||||
A4 operator[] (arg<4>) const { return a4_; }
|
||||
|
||||
A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
|
||||
A4 operator[] (boost::arg<4> (*) ()) const { return a4_; }
|
||||
A1 operator[] (arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (arg<3> (*) ()) const { return a3_; }
|
||||
A4 operator[] (arg<4> (*) ()) const { return a4_; }
|
||||
|
||||
template<class T> T & operator[] (value<T> & v) const { return v.get(); }
|
||||
|
||||
@@ -359,14 +314,9 @@ public:
|
||||
|
||||
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
|
||||
return f(a[a1_], a[a2_], a[a3_], a[a4_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -402,17 +352,17 @@ public:
|
||||
|
||||
list5(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5) {}
|
||||
|
||||
A1 operator[] (boost::arg<1>) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2>) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3>) const { return a3_; }
|
||||
A4 operator[] (boost::arg<4>) const { return a4_; }
|
||||
A5 operator[] (boost::arg<5>) const { return a5_; }
|
||||
A1 operator[] (arg<1>) const { return a1_; }
|
||||
A2 operator[] (arg<2>) const { return a2_; }
|
||||
A3 operator[] (arg<3>) const { return a3_; }
|
||||
A4 operator[] (arg<4>) const { return a4_; }
|
||||
A5 operator[] (arg<5>) const { return a5_; }
|
||||
|
||||
A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
|
||||
A4 operator[] (boost::arg<4> (*) ()) const { return a4_; }
|
||||
A5 operator[] (boost::arg<5> (*) ()) const { return a5_; }
|
||||
A1 operator[] (arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (arg<3> (*) ()) const { return a3_; }
|
||||
A4 operator[] (arg<4> (*) ()) const { return a4_; }
|
||||
A5 operator[] (arg<5> (*) ()) const { return a5_; }
|
||||
|
||||
template<class T> T & operator[] (value<T> & v) const { return v.get(); }
|
||||
|
||||
@@ -424,14 +374,9 @@ public:
|
||||
|
||||
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
|
||||
return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -469,19 +414,19 @@ public:
|
||||
|
||||
list6(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6) {}
|
||||
|
||||
A1 operator[] (boost::arg<1>) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2>) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3>) const { return a3_; }
|
||||
A4 operator[] (boost::arg<4>) const { return a4_; }
|
||||
A5 operator[] (boost::arg<5>) const { return a5_; }
|
||||
A6 operator[] (boost::arg<6>) const { return a6_; }
|
||||
A1 operator[] (arg<1>) const { return a1_; }
|
||||
A2 operator[] (arg<2>) const { return a2_; }
|
||||
A3 operator[] (arg<3>) const { return a3_; }
|
||||
A4 operator[] (arg<4>) const { return a4_; }
|
||||
A5 operator[] (arg<5>) const { return a5_; }
|
||||
A6 operator[] (arg<6>) const { return a6_; }
|
||||
|
||||
A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
|
||||
A4 operator[] (boost::arg<4> (*) ()) const { return a4_; }
|
||||
A5 operator[] (boost::arg<5> (*) ()) const { return a5_; }
|
||||
A6 operator[] (boost::arg<6> (*) ()) const { return a6_; }
|
||||
A1 operator[] (arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (arg<3> (*) ()) const { return a3_; }
|
||||
A4 operator[] (arg<4> (*) ()) const { return a4_; }
|
||||
A5 operator[] (arg<5> (*) ()) const { return a5_; }
|
||||
A6 operator[] (arg<6> (*) ()) const { return a6_; }
|
||||
|
||||
template<class T> T & operator[] (value<T> & v) const { return v.get(); }
|
||||
|
||||
@@ -493,14 +438,9 @@ public:
|
||||
|
||||
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
|
||||
return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -540,21 +480,21 @@ public:
|
||||
|
||||
list7(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7) {}
|
||||
|
||||
A1 operator[] (boost::arg<1>) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2>) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3>) const { return a3_; }
|
||||
A4 operator[] (boost::arg<4>) const { return a4_; }
|
||||
A5 operator[] (boost::arg<5>) const { return a5_; }
|
||||
A6 operator[] (boost::arg<6>) const { return a6_; }
|
||||
A7 operator[] (boost::arg<7>) const { return a7_; }
|
||||
A1 operator[] (arg<1>) const { return a1_; }
|
||||
A2 operator[] (arg<2>) const { return a2_; }
|
||||
A3 operator[] (arg<3>) const { return a3_; }
|
||||
A4 operator[] (arg<4>) const { return a4_; }
|
||||
A5 operator[] (arg<5>) const { return a5_; }
|
||||
A6 operator[] (arg<6>) const { return a6_; }
|
||||
A7 operator[] (arg<7>) const { return a7_; }
|
||||
|
||||
A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
|
||||
A4 operator[] (boost::arg<4> (*) ()) const { return a4_; }
|
||||
A5 operator[] (boost::arg<5> (*) ()) const { return a5_; }
|
||||
A6 operator[] (boost::arg<6> (*) ()) const { return a6_; }
|
||||
A7 operator[] (boost::arg<7> (*) ()) const { return a7_; }
|
||||
A1 operator[] (arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (arg<3> (*) ()) const { return a3_; }
|
||||
A4 operator[] (arg<4> (*) ()) const { return a4_; }
|
||||
A5 operator[] (arg<5> (*) ()) const { return a5_; }
|
||||
A6 operator[] (arg<6> (*) ()) const { return a6_; }
|
||||
A7 operator[] (arg<7> (*) ()) const { return a7_; }
|
||||
|
||||
template<class T> T & operator[] (value<T> & v) const { return v.get(); }
|
||||
|
||||
@@ -566,14 +506,9 @@ public:
|
||||
|
||||
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
|
||||
return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -615,23 +550,23 @@ public:
|
||||
|
||||
list8(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8) {}
|
||||
|
||||
A1 operator[] (boost::arg<1>) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2>) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3>) const { return a3_; }
|
||||
A4 operator[] (boost::arg<4>) const { return a4_; }
|
||||
A5 operator[] (boost::arg<5>) const { return a5_; }
|
||||
A6 operator[] (boost::arg<6>) const { return a6_; }
|
||||
A7 operator[] (boost::arg<7>) const { return a7_; }
|
||||
A8 operator[] (boost::arg<8>) const { return a8_; }
|
||||
A1 operator[] (arg<1>) const { return a1_; }
|
||||
A2 operator[] (arg<2>) const { return a2_; }
|
||||
A3 operator[] (arg<3>) const { return a3_; }
|
||||
A4 operator[] (arg<4>) const { return a4_; }
|
||||
A5 operator[] (arg<5>) const { return a5_; }
|
||||
A6 operator[] (arg<6>) const { return a6_; }
|
||||
A7 operator[] (arg<7>) const { return a7_; }
|
||||
A8 operator[] (arg<8>) const { return a8_; }
|
||||
|
||||
A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
|
||||
A4 operator[] (boost::arg<4> (*) ()) const { return a4_; }
|
||||
A5 operator[] (boost::arg<5> (*) ()) const { return a5_; }
|
||||
A6 operator[] (boost::arg<6> (*) ()) const { return a6_; }
|
||||
A7 operator[] (boost::arg<7> (*) ()) const { return a7_; }
|
||||
A8 operator[] (boost::arg<8> (*) ()) const { return a8_; }
|
||||
A1 operator[] (arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (arg<3> (*) ()) const { return a3_; }
|
||||
A4 operator[] (arg<4> (*) ()) const { return a4_; }
|
||||
A5 operator[] (arg<5> (*) ()) const { return a5_; }
|
||||
A6 operator[] (arg<6> (*) ()) const { return a6_; }
|
||||
A7 operator[] (arg<7> (*) ()) const { return a7_; }
|
||||
A8 operator[] (arg<8> (*) ()) const { return a8_; }
|
||||
|
||||
template<class T> T & operator[] (value<T> & v) const { return v.get(); }
|
||||
|
||||
@@ -643,14 +578,9 @@ public:
|
||||
|
||||
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
|
||||
return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -694,25 +624,25 @@ public:
|
||||
|
||||
list9(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9) {}
|
||||
|
||||
A1 operator[] (boost::arg<1>) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2>) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3>) const { return a3_; }
|
||||
A4 operator[] (boost::arg<4>) const { return a4_; }
|
||||
A5 operator[] (boost::arg<5>) const { return a5_; }
|
||||
A6 operator[] (boost::arg<6>) const { return a6_; }
|
||||
A7 operator[] (boost::arg<7>) const { return a7_; }
|
||||
A8 operator[] (boost::arg<8>) const { return a8_; }
|
||||
A9 operator[] (boost::arg<9>) const { return a9_; }
|
||||
A1 operator[] (arg<1>) const { return a1_; }
|
||||
A2 operator[] (arg<2>) const { return a2_; }
|
||||
A3 operator[] (arg<3>) const { return a3_; }
|
||||
A4 operator[] (arg<4>) const { return a4_; }
|
||||
A5 operator[] (arg<5>) const { return a5_; }
|
||||
A6 operator[] (arg<6>) const { return a6_; }
|
||||
A7 operator[] (arg<7>) const { return a7_; }
|
||||
A8 operator[] (arg<8>) const { return a8_; }
|
||||
A9 operator[] (arg<9>) const { return a9_; }
|
||||
|
||||
A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
|
||||
A4 operator[] (boost::arg<4> (*) ()) const { return a4_; }
|
||||
A5 operator[] (boost::arg<5> (*) ()) const { return a5_; }
|
||||
A6 operator[] (boost::arg<6> (*) ()) const { return a6_; }
|
||||
A7 operator[] (boost::arg<7> (*) ()) const { return a7_; }
|
||||
A8 operator[] (boost::arg<8> (*) ()) const { return a8_; }
|
||||
A9 operator[] (boost::arg<9> (*) ()) const { return a9_; }
|
||||
A1 operator[] (arg<1> (*) ()) const { return a1_; }
|
||||
A2 operator[] (arg<2> (*) ()) const { return a2_; }
|
||||
A3 operator[] (arg<3> (*) ()) const { return a3_; }
|
||||
A4 operator[] (arg<4> (*) ()) const { return a4_; }
|
||||
A5 operator[] (arg<5> (*) ()) const { return a5_; }
|
||||
A6 operator[] (arg<6> (*) ()) const { return a6_; }
|
||||
A7 operator[] (arg<7> (*) ()) const { return a7_; }
|
||||
A8 operator[] (arg<8> (*) ()) const { return a8_; }
|
||||
A9 operator[] (arg<9> (*) ()) const { return a9_; }
|
||||
|
||||
template<class T> T & operator[] (value<T> & v) const { return v.get(); }
|
||||
|
||||
@@ -724,14 +654,9 @@ public:
|
||||
|
||||
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
|
||||
{
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
|
||||
return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -776,180 +701,180 @@ private:
|
||||
template <class R> struct evaluator0
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L &, F f, A &)
|
||||
static R eval(L const&, F f, A &)
|
||||
{
|
||||
return unwrap(f, 0)();
|
||||
return f();
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator0<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L &, F f, A &)
|
||||
static void eval(L const&, F f, A &)
|
||||
{
|
||||
unwrap(f, 0)();
|
||||
f();
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator1
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L & l, F f, A & a)
|
||||
static R eval(L const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[l.a1_]);
|
||||
return f(a[l.a1_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator1<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L & l, F f, A & a)
|
||||
static void eval(L const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(a[l.a1_]);
|
||||
f(a[l.a1_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator2
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L & l, F f, A & a)
|
||||
static R eval(L const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[l.a1_], a[l.a2_]);
|
||||
return f(a[l.a1_], a[l.a2_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator2<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L & l, F f, A & a)
|
||||
static void eval(L const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(a[l.a1_], a[l.a2_]);
|
||||
f(a[l.a1_], a[l.a2_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator3
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L & l, F f, A & a)
|
||||
static R eval(L const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
|
||||
return f(a[l.a1_], a[l.a2_], a[l.a3_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator3<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L & l, F f, A & a)
|
||||
static void eval(L const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
|
||||
f(a[l.a1_], a[l.a2_], a[l.a3_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator4
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L & l, F f, A & a)
|
||||
static R eval(L const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
|
||||
return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator4<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L & l, F f, A & a)
|
||||
static void eval(L const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
|
||||
f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator5
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L & l, F f, A & a)
|
||||
static R eval(L const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
|
||||
return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator5<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L & l, F f, A & a)
|
||||
static void eval(L const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
|
||||
f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator6
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L & l, F f, A & a)
|
||||
static R eval(L const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
|
||||
return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator6<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L & l, F f, A & a)
|
||||
static void eval(L const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
|
||||
f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator7
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L & l, F f, A & a)
|
||||
static R eval(L const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
|
||||
return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator7<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L & l, F f, A & a)
|
||||
static void eval(L const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
|
||||
f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator8
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L & l, F f, A & a)
|
||||
static R eval(L const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
|
||||
return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator8<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L & l, F f, A & a)
|
||||
static void eval(L const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
|
||||
f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator9
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L & l, F f, A & a)
|
||||
static R eval(L const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
|
||||
return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator9<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L & l, F f, A & a)
|
||||
static void eval(L const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
|
||||
f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
|
||||
}
|
||||
};
|
||||
|
||||
@@ -1042,12 +967,12 @@ template<class T> struct add_value< reference_wrapper<T> >
|
||||
|
||||
template<int I> struct add_value< arg<I> >
|
||||
{
|
||||
typedef boost::arg<I> type;
|
||||
typedef arg<I> type;
|
||||
};
|
||||
|
||||
template<int I> struct add_value< arg<I> (*) () >
|
||||
{
|
||||
typedef boost::arg<I> (*type) ();
|
||||
typedef arg<I> (*type) ();
|
||||
};
|
||||
|
||||
template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
|
||||
@@ -1186,18 +1111,6 @@ template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, c
|
||||
typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
|
||||
};
|
||||
|
||||
// g++ 2.95 specific helper; used by the data member overload
|
||||
|
||||
template<class T> struct add_cref
|
||||
{
|
||||
typedef T const & type;
|
||||
};
|
||||
|
||||
template<> struct add_cref<void>
|
||||
{
|
||||
typedef void type;
|
||||
};
|
||||
|
||||
} // namespace _bi
|
||||
|
||||
// visit_each
|
||||
@@ -1300,88 +1213,6 @@ template<class R, class F, class A1, class A2, class A3, class A4, class A5, cla
|
||||
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
|
||||
}
|
||||
|
||||
// generic function objects, alternative syntax
|
||||
|
||||
template<class R, class F>
|
||||
_bi::bind_t<R, F, _bi::list0>
|
||||
BOOST_BIND(boost::type<R>, F f)
|
||||
{
|
||||
typedef _bi::list0 list_type;
|
||||
return _bi::bind_t<R, F, list_type> (f, list_type());
|
||||
}
|
||||
|
||||
template<class R, class F, class A1>
|
||||
_bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
|
||||
BOOST_BIND(boost::type<R>, F f, A1 a1)
|
||||
{
|
||||
typedef typename _bi::list_av_1<A1>::type list_type;
|
||||
return _bi::bind_t<R, F, list_type> (f, list_type(a1));
|
||||
}
|
||||
|
||||
template<class R, class F, class A1, class A2>
|
||||
_bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
|
||||
BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2)
|
||||
{
|
||||
typedef typename _bi::list_av_2<A1, A2>::type list_type;
|
||||
return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
|
||||
}
|
||||
|
||||
template<class R, class F, class A1, class A2, class A3>
|
||||
_bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
|
||||
BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
|
||||
{
|
||||
typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
|
||||
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
|
||||
}
|
||||
|
||||
template<class R, class F, class A1, class A2, class A3, class A4>
|
||||
_bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
|
||||
BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
|
||||
{
|
||||
typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
|
||||
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
|
||||
}
|
||||
|
||||
template<class R, class F, class A1, class A2, class A3, class A4, class A5>
|
||||
_bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
|
||||
BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
|
||||
{
|
||||
typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
|
||||
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
|
||||
}
|
||||
|
||||
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
_bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
|
||||
BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
|
||||
{
|
||||
typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
|
||||
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
|
||||
}
|
||||
|
||||
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
_bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
|
||||
BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
|
||||
{
|
||||
typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
|
||||
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
|
||||
}
|
||||
|
||||
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
_bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
|
||||
BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
|
||||
{
|
||||
typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
|
||||
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
|
||||
}
|
||||
|
||||
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
|
||||
_bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
|
||||
BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
|
||||
{
|
||||
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
|
||||
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
|
||||
}
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
|
||||
|
||||
// adaptable function objects
|
||||
@@ -1490,18 +1321,6 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_BIND_ENABLE_FASTCALL
|
||||
|
||||
#define BOOST_BIND_CC __fastcall
|
||||
#define BOOST_BIND_ST
|
||||
|
||||
#include <boost/bind/bind_cc.hpp>
|
||||
|
||||
#undef BOOST_BIND_CC
|
||||
#undef BOOST_BIND_ST
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_BIND_ENABLE_PASCAL
|
||||
|
||||
#define BOOST_BIND_ST pascal
|
||||
@@ -1536,44 +1355,17 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
|
||||
|
||||
#define BOOST_BIND_MF_NAME(X) X##_fastcall
|
||||
#define BOOST_BIND_MF_CC __fastcall
|
||||
|
||||
#include <boost/bind/bind_mf_cc.hpp>
|
||||
|
||||
#undef BOOST_BIND_MF_NAME
|
||||
#undef BOOST_BIND_MF_CC
|
||||
|
||||
#endif
|
||||
|
||||
// data member pointers
|
||||
|
||||
#if defined(__GNUC__) && (__GNUC__ == 2)
|
||||
|
||||
template<class R, class T, class A1>
|
||||
_bi::bind_t< typename _bi::add_cref<R>::type, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
|
||||
_bi::bind_t< R, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
|
||||
BOOST_BIND(R T::*f, A1 a1)
|
||||
{
|
||||
typedef _mfi::dm<R, T> F;
|
||||
typedef typename _bi::list_av_1<A1>::type list_type;
|
||||
return _bi::bind_t<typename _bi::add_cref<R>::type, F, list_type>(F(f), list_type(a1));
|
||||
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
template<class R, class T, class A1>
|
||||
_bi::bind_t< R const &, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
|
||||
BOOST_BIND(R T::*f, A1 a1)
|
||||
{
|
||||
typedef _mfi::dm<R, T> F;
|
||||
typedef typename _bi::list_av_1<A1>::type list_type;
|
||||
return _bi::bind_t<R const &, F, list_type>(F(f), list_type(a1));
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#ifndef BOOST_BIND_NO_PLACEHOLDERS
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
//
|
||||
// apply.hpp
|
||||
//
|
||||
// Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
@@ -19,52 +19,52 @@ template<class R> struct apply
|
||||
{
|
||||
typedef R result_type;
|
||||
|
||||
template<class F> result_type operator()(F & f) const
|
||||
template<class F> result_type operator()(F f) const
|
||||
{
|
||||
return f();
|
||||
}
|
||||
|
||||
template<class F, class A1> result_type operator()(F & f, A1 & a1) const
|
||||
template<class F, class A1> result_type operator()(F f, A1 & a1) const
|
||||
{
|
||||
return f(a1);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2> result_type operator()(F & f, A1 & a1, A2 & a2) const
|
||||
template<class F, class A1, class A2> result_type operator()(F f, A1 & a1, A2 & a2) const
|
||||
{
|
||||
return f(a1, a2);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3) const
|
||||
template<class F, class A1, class A2, class A3> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3) const
|
||||
{
|
||||
return f(a1, a2, a3);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3, class A4> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
|
||||
template<class F, class A1, class A2, class A3, class A4> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
|
||||
{
|
||||
return f(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
|
||||
{
|
||||
return f(a1, a2, a3, a4, a5);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
|
||||
{
|
||||
return f(a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
|
||||
{
|
||||
return f(a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
|
||||
{
|
||||
return f(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
|
||||
{
|
||||
return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
#ifndef BOOST_BIND_ARG_HPP_INCLUDED
|
||||
#define BOOST_BIND_ARG_HPP_INCLUDED
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#if _MSC_VER >= 1020
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
//
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
#ifndef BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
|
||||
#define BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#if _MSC_VER >= 1020
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
//
|
||||
@@ -38,7 +36,7 @@ static inline boost::arg<7> _7() { return boost::arg<7>(); }
|
||||
static inline boost::arg<8> _8() { return boost::arg<8>(); }
|
||||
static inline boost::arg<9> _9() { return boost::arg<9>(); }
|
||||
|
||||
#elif (defined(BOOST_MSVC) && BOOST_MSVC <= 1300) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__)
|
||||
#elif defined(BOOST_MSVC)
|
||||
|
||||
static boost::arg<1> _1;
|
||||
static boost::arg<2> _2;
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
#ifndef BOOST_MEM_FN_HPP_INCLUDED
|
||||
#define BOOST_MEM_FN_HPP_INCLUDED
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#if _MSC_VER+0 >= 1020
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
//
|
||||
@@ -22,12 +20,19 @@
|
||||
//
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/get_pointer.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
// get_pointer(p) extracts a ->* capable pointer from p
|
||||
|
||||
template<class T> T * get_pointer(T * p)
|
||||
{
|
||||
return p;
|
||||
}
|
||||
|
||||
// get_pointer(shared_ptr<T> const & p) has been moved to shared_ptr.hpp
|
||||
|
||||
#if defined(BOOST_NO_VOID_RETURNS)
|
||||
|
||||
#define BOOST_MEM_FN_CLASS_F , class F
|
||||
@@ -61,18 +66,6 @@ template<class V> struct mf
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
|
||||
#define BOOST_MEM_FN_CC __fastcall
|
||||
|
||||
#include <boost/bind/mem_fn_template.hpp>
|
||||
|
||||
#undef BOOST_MEM_FN_CC
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
|
||||
#endif
|
||||
|
||||
#undef BOOST_MEM_FN_RETURN
|
||||
|
||||
}; // struct mf<V>
|
||||
@@ -102,18 +95,6 @@ template<> struct mf<void>
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
|
||||
#define BOOST_MEM_FN_CC __fastcall
|
||||
|
||||
#include <boost/bind/mem_fn_template.hpp>
|
||||
|
||||
#undef BOOST_MEM_FN_CC
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
|
||||
#endif
|
||||
|
||||
#undef BOOST_MEM_FN_RETURN
|
||||
|
||||
}; // struct mf<void>
|
||||
@@ -145,20 +126,6 @@ template<> struct mf<void>
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) X##_fastcall
|
||||
#define BOOST_MEM_FN_NAME2(X) inner_##X##_fastcall
|
||||
#define BOOST_MEM_FN_CC __fastcall
|
||||
|
||||
#include <boost/bind/mem_fn_vw.hpp>
|
||||
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
#undef BOOST_MEM_FN_NAME2
|
||||
#undef BOOST_MEM_FN_CC
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace _mfi
|
||||
|
||||
#else // #ifdef BOOST_NO_VOID_RETURNS
|
||||
@@ -191,18 +158,6 @@ namespace _mfi
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) X##_fastcall
|
||||
#define BOOST_MEM_FN_CC __fastcall
|
||||
|
||||
#include <boost/bind/mem_fn_template.hpp>
|
||||
|
||||
#undef BOOST_MEM_FN_CC
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
|
||||
#endif
|
||||
|
||||
#undef BOOST_MEM_FN_RETURN
|
||||
|
||||
} // namespace _mfi
|
||||
@@ -232,18 +187,6 @@ namespace _mfi
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) X##_fastcall
|
||||
#define BOOST_MEM_FN_CC __fastcall
|
||||
|
||||
#include <boost/bind/mem_fn_cc.hpp>
|
||||
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
#undef BOOST_MEM_FN_CC
|
||||
|
||||
#endif
|
||||
|
||||
// data member support
|
||||
|
||||
namespace _mfi
|
||||
@@ -295,7 +238,7 @@ public:
|
||||
return call(u, &u);
|
||||
}
|
||||
|
||||
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
|
||||
#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1300)
|
||||
|
||||
R & operator()(T & t) const
|
||||
{
|
||||
|
||||
10
index.html
10
index.html
@@ -1,10 +0,0 @@
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=bind.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="bind.html">bind.html</a> or
|
||||
<a href="mem_fn.html">mem_fn.html</a>.
|
||||
</body>
|
||||
</html>
|
||||
98
mem_fn.html
98
mem_fn.html
@@ -37,17 +37,14 @@
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#Files">Files</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#Dependencies">Dependencies</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#NumberOfArguments">Number of Arguments</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#stdcall">"__stdcall" and
|
||||
"__fastcall" Support</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#stdcall">"__stdcall" Support</a></h4>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><a href="#Acknowledgements">Acknowledgements</a></h3>
|
||||
<h2><a name="Purpose">Purpose</a></h2>
|
||||
<p>
|
||||
<b>boost::mem_fn</b> is a generalization of the standard functions <b>std::mem_fun</b>
|
||||
and <b>std::mem_fun_ref</b>. It supports member function pointers with more
|
||||
than one argument, and the returned function object can take a pointer, a
|
||||
reference, or a smart pointer to an object instance as its first argument. <STRONG>mem_fn</STRONG>
|
||||
also supports pointers to data members by treating them as functions taking no
|
||||
arguments and returning a (const) reference to the member.
|
||||
reference, or a smart pointer to an object instance as its first argument.
|
||||
</p>
|
||||
<p>
|
||||
The purpose of <b>mem_fn</b> is twofold. First, it allows users to invoke a
|
||||
@@ -89,8 +86,8 @@ template<class It, class R, class T> void for_each(It first, It last, R (T
|
||||
documentation of <b>bind</b></a> for an example.
|
||||
</p>
|
||||
<p>
|
||||
<b>mem_fn</b> takes one argument, a pointer to a member, and returns a function
|
||||
object suitable for use with standard or user-defined algorithms:
|
||||
<b>mem_fn</b> takes one argument, a pointer to a member function, and returns a
|
||||
function object suitable for use with standard or user-defined algorithms:
|
||||
</p>
|
||||
<pre>
|
||||
struct X
|
||||
@@ -138,8 +135,7 @@ void k(std::vector<boost::shared_ptr<X> > const & v)
|
||||
</p>
|
||||
<p>
|
||||
All function objects returned by <b>mem_fn</b> expose a <b>result_type</b> typedef
|
||||
that represents the return type of the member function. For data members, <STRONG>result_type</STRONG>
|
||||
is defined as a const reference to the type of the member.
|
||||
that represents the return type of the member function.
|
||||
</p>
|
||||
<h2><a name="FAQ">Frequently Asked Questions</a></h2>
|
||||
<h3><a name="Q1">Can <b>mem_fn</b> be used instead of the standard <b>std::mem_fun[_ref]</b>
|
||||
@@ -179,21 +175,19 @@ void k(std::vector<boost::shared_ptr<X> > const & v)
|
||||
namespace boost
|
||||
{
|
||||
|
||||
template<class T> T * <a href="#get_pointer_1">get_pointer</a>(T * p);
|
||||
template<class T> T * <a href="#get_pointer_1">get_pointer</a> (T * p);
|
||||
|
||||
template<class R, class T> <i>unspecified-1</i> <a href="#mem_fn_1">mem_fn</a>(R (T::*pmf) ());
|
||||
template<class R, class T> <i>implementation-defined-1</i> <a href="#mem_fn_1">mem_fn</a>(R (T::*pmf) ());
|
||||
|
||||
template<class R, class T> <i>unspecified-2</i> <a href="#mem_fn_2">mem_fn</a>(R (T::*pmf) () const);
|
||||
template<class R, class T> <i>implementation-defined-2</i> <a href="#mem_fn_2">mem_fn</a>(R (T::*pmf) () const);
|
||||
|
||||
template<class R, class T> <i>unspecified-2-1</i> <a href="#mem_fn_2_1">mem_fn</a>(R T::*pm);
|
||||
template<class R, class T, class A1> <i>implementation-defined-3</i> <a href="#mem_fn_3">mem_fn</a>(R (T::*pmf) (A1));
|
||||
|
||||
template<class R, class T, class A1> <i>unspecified-3</i> <a href="#mem_fn_3">mem_fn</a>(R (T::*pmf) (A1));
|
||||
template<class R, class T, class A1> <i>implementation-defined-4</i> <a href="#mem_fn_4">mem_fn</a>(R (T::*pmf) (A1) const);
|
||||
|
||||
template<class R, class T, class A1> <i>unspecified-4</i> <a href="#mem_fn_4">mem_fn</a>(R (T::*pmf) (A1) const);
|
||||
template<class R, class T, class A1, class A2> <i>implementation-defined-5</i> <a href="#mem_fn_5">mem_fn</a>(R (T::*pmf) (A1, A2));
|
||||
|
||||
template<class R, class T, class A1, class A2> <i>unspecified-5</i> <a href="#mem_fn_5">mem_fn</a>(R (T::*pmf) (A1, A2));
|
||||
|
||||
template<class R, class T, class A1, class A2> <i>unspecified-6</i> <a href="#mem_fn_6">mem_fn</a>(R (T::*pmf) (A1, A2) const);
|
||||
template<class R, class T, class A1, class A2> <i>implementation-defined-6</i> <a href="#mem_fn_6">mem_fn</a>(R (T::*pmf) (A1, A2) const);
|
||||
|
||||
// implementation defined number of additional overloads for more arguments
|
||||
|
||||
@@ -201,12 +195,11 @@ template<class R, class T, class A1, class A2> <i>unspecified-6</i> <a hre
|
||||
</pre>
|
||||
<h3><a name="CommonRequirements">Common requirements</a></h3>
|
||||
<p>
|
||||
All <tt><i>unspecified-N</i></tt> types mentioned in the Synopsis are <b>CopyConstructible</b>
|
||||
and <b>Assignable</b>. Their copy constructors and assignment operators do not
|
||||
throw exceptions. <tt><i>unspecified-N</i>::result_type</tt> is defined as the
|
||||
return type of the member function pointer passed as an argument to <b>mem_fn</b>
|
||||
(<b>R</b> in the Synopsis.) <tt><i>unspecified-2-1</i>::result_type</tt> is
|
||||
defined as <tt>R const &</tt>.
|
||||
All <tt><i>implementation-defined-N</i></tt> types mentioned in the Synopsis
|
||||
are <b>CopyConstructible</b> and <b>Assignable</b>. Their copy constructors and
|
||||
assignment operators do not throw exceptions. <tt><i>implementation-defined-N</i>::result_type</tt>
|
||||
is defined as the return type of the member function pointer passed as an
|
||||
argument to <b>mem_fn</b> (<b>R</b> in the Synopsis.)
|
||||
</p>
|
||||
<h3><a name="get_pointer">get_pointer</a></h3>
|
||||
<h4><a name="get_pointer_1">template<class T> T * get_pointer(T * p)</a></h4>
|
||||
@@ -219,8 +212,8 @@ template<class R, class T, class A1, class A2> <i>unspecified-6</i> <a hre
|
||||
</p>
|
||||
</blockquote>
|
||||
<h3><a name="mem_fn">mem_fn</a></h3>
|
||||
<h4><a name="mem_fn_1">template<class R, class T> <i>unspecified-1</i> mem_fn(R
|
||||
(T::*pmf) ())</a></h4>
|
||||
<h4><a name="mem_fn_1">template<class R, class T> <i>implementation-defined-1</i>
|
||||
mem_fn(R (T::*pmf) ())</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
|
||||
@@ -231,8 +224,8 @@ template<class R, class T, class A1, class A2> <i>unspecified-6</i> <a hre
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="mem_fn_2">template<class R, class T> <i>unspecified-2</i> mem_fn(R
|
||||
(T::*pmf) () const)</a></h4>
|
||||
<h4><a name="mem_fn_2">template<class R, class T> <i>implementation-defined-2</i>
|
||||
mem_fn(R (T::*pmf) () const)</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
|
||||
@@ -244,20 +237,8 @@ template<class R, class T, class A1, class A2> <i>unspecified-6</i> <a hre
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="mem_fn_2_1">template<class R, class T> <i>unspecified-2-1</i> mem_fn(R
|
||||
T::*pm)</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
|
||||
is equivalent to <tt>t.*pm</tt> when <i>t</i> is of type <STRONG>T</STRONG> <EM>[const]<STRONG>
|
||||
</STRONG></EM>or derived, <tt>get_pointer(t)->*pm</tt> otherwise.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="mem_fn_3">template<class R, class T, class A1> <i>unspecified-3</i> mem_fn(R
|
||||
(T::*pmf) (A1))</a></h4>
|
||||
<h4><a name="mem_fn_3">template<class R, class T, class A1> <i>implementation-defined-3</i>
|
||||
mem_fn(R (T::*pmf) (A1))</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1)</i></tt>
|
||||
@@ -268,8 +249,8 @@ template<class R, class T, class A1, class A2> <i>unspecified-6</i> <a hre
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="mem_fn_4">template<class R, class T, class A1> <i>unspecified-4</i> mem_fn(R
|
||||
(T::*pmf) (A1) const)</a></h4>
|
||||
<h4><a name="mem_fn_4">template<class R, class T, class A1> <i>implementation-defined-4</i>
|
||||
mem_fn(R (T::*pmf) (A1) const)</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1)</i></tt>
|
||||
@@ -281,7 +262,7 @@ template<class R, class T, class A1, class A2> <i>unspecified-6</i> <a hre
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="mem_fn_5">template<class R, class T, class A1, class A2> <i>unspecified-5</i>
|
||||
<h4><a name="mem_fn_5">template<class R, class T, class A1, class A2> <i>implementation-defined-5</i>
|
||||
mem_fn(R (T::*pmf) (A1, A2))</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
@@ -293,7 +274,7 @@ template<class R, class T, class A1, class A2> <i>unspecified-6</i> <a hre
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="mem_fn_6">template<class R, class T, class A1, class A2> <i>unspecified-6</i>
|
||||
<h4><a name="mem_fn_6">template<class R, class T, class A1, class A2> <i>implementation-defined-6</i>
|
||||
mem_fn(R (T::*pmf) (A1, A2) const)</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
@@ -321,19 +302,13 @@ template<class R, class T, class A1, class A2> <i>unspecified-6</i> <a hre
|
||||
<a href="../../boost/bind/mem_fn_template.hpp">boost/bind/mem_fn_template.hpp</a>
|
||||
(used by mem_fn.hpp, do not include directly)
|
||||
<li>
|
||||
<a href="test/mem_fn_test.cpp">libs/bind/test/mem_fn_test.cpp</a>
|
||||
<a href="mem_fn_test.cpp">libs/bind/mem_fn_test.cpp</a>
|
||||
(test)
|
||||
<li>
|
||||
<a href="test/mem_fn_derived_test.cpp">libs/bind/test/mem_fn_derived_test.cpp</a>
|
||||
(test with derived objects)
|
||||
<li>
|
||||
<a href="test/mem_fn_fastcall_test.cpp">libs/bind/test/mem_fn_fastcall_test.cpp</a>
|
||||
(test for __fastcall)
|
||||
<li>
|
||||
<a href="test/mem_fn_stdcall_test.cpp">libs/bind/test/mem_fn_stdcall_test.cpp</a>
|
||||
<a href="mem_fn_stdcall_test.cpp">libs/bind/mem_fn_stdcall_test.cpp</a>
|
||||
(test for __stdcall)
|
||||
<li>
|
||||
<a href="test/mem_fn_void_test.cpp">libs/bind/test/mem_fn_void_test.cpp</a> (test for
|
||||
<a href="mem_fn_void_test.cpp">libs/bind/mem_fn_void_test.cpp</a> (test for
|
||||
void returns)</li>
|
||||
</ul>
|
||||
<h3><a name="Dependencies">Dependencies</a></h3>
|
||||
@@ -346,7 +321,7 @@ template<class R, class T, class A1, class A2> <i>unspecified-6</i> <a hre
|
||||
This implementation supports member functions with up to eight arguments. This
|
||||
is not an inherent limitation of the design, but an implementation detail.
|
||||
</p>
|
||||
<h3><a name="stdcall">"__stdcall" and "__fastcall" Support</a></h3>
|
||||
<h3><a name="stdcall">"__stdcall" Support</a></h3>
|
||||
<p>
|
||||
Some platforms allow several types of member functions that differ by their <b>calling
|
||||
convention</b> (the rules by which the function is invoked: how are
|
||||
@@ -355,19 +330,16 @@ template<class R, class T, class A1, class A2> <i>unspecified-6</i> <a hre
|
||||
</p>
|
||||
<p>
|
||||
For example, Windows API functions and COM interface member functions use a
|
||||
calling convention known as <b>__stdcall</b>. Borland VCL components use <STRONG>__fastcall</STRONG>.
|
||||
calling convention known as <b>__stdcall</b>.
|
||||
</p>
|
||||
<p>
|
||||
To use <b>mem_fn</b> with <b>__stdcall</b> member functions, <b>#define</b> the
|
||||
macro <b>BOOST_MEM_FN_ENABLE_STDCALL</b> before including, directly or
|
||||
indirectly, <b><boost/mem_fn.hpp></b>.
|
||||
</p>
|
||||
<P>To use <B>mem_fn</B> with <B>__fastcall</B> member functions, <B>#define</B> the
|
||||
macro <B>BOOST_MEM_FN_ENABLE_FASTCALL</B> before including, directly or
|
||||
indirectly, <B><boost/mem_fn.hpp></B>.
|
||||
</P>
|
||||
<P>[Note: this is a non-portable extension. It is not part of the interface.]
|
||||
</P>
|
||||
<p>
|
||||
[Note: this is a non-portable extension. It is not part of the interface.]
|
||||
</p>
|
||||
<p>
|
||||
[Note: Some compilers provide only minimal support for the <b>__stdcall</b> keyword.]
|
||||
</p>
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
200
ref.html
200
ref.html
@@ -1,9 +1,195 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=../../doc/html/ref.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="../../doc/html/ref.html">../../doc/html/ref.html</a>
|
||||
</body>
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
<title>Boost: ref.hpp documentation</title>
|
||||
</head>
|
||||
<body bgcolor="White">
|
||||
<table border="0" width="100%">
|
||||
<tr>
|
||||
<td width="277">
|
||||
<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
|
||||
</td>
|
||||
<td align="center">
|
||||
<table border="0">
|
||||
<tr>
|
||||
<td nowrap><h1>ref.hpp</h1>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td align="right" nowrap><small> 1.00.0004 (2002-01-27)</small></td>
|
||||
</tr>
|
||||
</table>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td colspan="2" height="64"> </td>
|
||||
</tr>
|
||||
</table>
|
||||
<h2>Files</h2>
|
||||
<ul>
|
||||
<li>
|
||||
<a href="../../boost/ref.hpp">ref.hpp</a>
|
||||
</ul>
|
||||
<h2>Purpose</h2>
|
||||
<p>
|
||||
The header <a href="../../boost/ref.hpp">boost/ref.hpp</a> defines the class
|
||||
template <b>boost::reference_wrapper<T></b>, the two functions <b>boost::ref</b>
|
||||
and <b>boost::cref</b> that return instances of <b>boost::reference_wrapper<T></b>,
|
||||
and the two traits classes <b>boost::is_reference_wrapper<T></b> and <b>boost::unwrap_reference<T></b>.
|
||||
</p>
|
||||
<p>
|
||||
The purpose of <b>boost::reference_wrapper<T></b> is to contain a
|
||||
reference to an object of type <b>T</b>. It is primarily used to "feed"
|
||||
references to function templates (algorithms) that take their parameter by
|
||||
value.
|
||||
</p>
|
||||
<p>
|
||||
To support this usage, <b>boost::reference_wrapper<T></b> provides an
|
||||
implicit conversion to <b>T &</b>. This usually allows the function
|
||||
templates to work on references unmodified.
|
||||
</p>
|
||||
<p>
|
||||
<b>boost::reference_wrapper<T></b> is both <b>CopyConstructible</b> and <b>Assignable</b>
|
||||
(ordinary references are not <b>Assignable</b>).
|
||||
</p>
|
||||
<p>
|
||||
The expression <b>boost::ref(x)</b> returns a <b>boost::reference_wrapper<X>(x)</b>
|
||||
where <b>X</b> is the type of <b>x</b>. Similarly, <b>boost::cref(x)</b> returns
|
||||
a <b>boost::reference_wrapper<X const>(x)</b>.
|
||||
</p>
|
||||
<p>
|
||||
The expression <b>boost::is_reference_wrapper<T>::value</b> is <b>true</b>
|
||||
if <b>T</b> is a <b>reference_wrapper</b>, and <b>false</b>
|
||||
otherwise.
|
||||
</p>
|
||||
<p>
|
||||
The type-expression <b>boost::unwrap_reference<T>::type</b> is <b>T::type</b>
|
||||
if <b>T</b> is a <b>reference_wrapper</b>, <b>T</b> otherwise.
|
||||
</p>
|
||||
<h2>Interface</h2>
|
||||
<h3>Synopsis</h3>
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
template<class T> class <a href="#reference_wrapper">reference_wrapper</a>;
|
||||
template<class T> reference_wrapper<T> <a href="#ref">ref</a>(T & t);
|
||||
template<class T> reference_wrapper<T const> <a href="#cref">cref</a>(T const & t);
|
||||
template<class T> class is_reference_wrapper<T const>;
|
||||
template<class T> class unwrap_reference<T const>;
|
||||
}
|
||||
</pre>
|
||||
<h3><a name="reference_wrapper">reference_wrapper</a></h3>
|
||||
<pre>
|
||||
template<class T> class reference_wrapper
|
||||
{
|
||||
public:
|
||||
typedef T type;
|
||||
|
||||
explicit <a href="#rt_construct">reference_wrapper</a>(T & t);
|
||||
|
||||
<a href="#rt_operator">operator T &</a> () const;
|
||||
|
||||
T & <a href="#rt_get">get</a>() const;
|
||||
T* <a href="#rt_get_pointer">get_pointer</a>() const;
|
||||
};
|
||||
</pre>
|
||||
<h4><a name="rt_construct">explicit reference_wrapper(T & t)</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Effects:</b> Constructs a <b>reference_wrapper</b> object that stores a
|
||||
reference to <b>t</b>.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="rt_operator">operator T & () const</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> the stored reference.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="rt_get">T & get() const</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> the stored reference.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="rt_get_pointer">T* get_pointer() const</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a pointer to the stored object.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h3><a name="ref">ref</a></h3>
|
||||
<pre>
|
||||
template<class T> reference_wrapper<T> ref(T & t);
|
||||
</pre>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> <tt>reference_wrapper<T>(t)</tt>.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h3><a name="cref">cref</a></h3>
|
||||
<pre>
|
||||
template<class T> reference_wrapper<T const> cref(T const & t);
|
||||
</pre>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> <tt>reference_wrapper<T const>(t)</tt>.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h3><a name="is_reference_wrapper">is_reference_wrapper</a></h3>
|
||||
<pre>
|
||||
template<class T> class is_reference_wrapper<T const>
|
||||
{
|
||||
public:
|
||||
static bool value = <i>unspecified</i>;
|
||||
};
|
||||
</pre>
|
||||
Value is <b>true</b> iff <tt>T</tt> is a specialization of <tt>reference_wrapper</tt>.
|
||||
<h3><a name="unwrap_reference">unwrap_reference</a></h3>
|
||||
<pre>
|
||||
template<class T> class unwrap_reference<T const>
|
||||
{
|
||||
public:
|
||||
typedef <i>unspecified</i> type;
|
||||
};
|
||||
</pre>
|
||||
<tt>type</tt> is equivalent to <tt>T::type</tt> if <tt>T</tt> is a
|
||||
specialization of <tt>reference_wrapper</tt>. Otherwise <tt>type</tt> is
|
||||
equivalent to <tt>T</tt>.
|
||||
<h2>Acknowledgements</h2>
|
||||
<p>
|
||||
<b>ref</b> and <b>cref</b> were originally part of the Boost.Tuple library by <a href="../../people/jaakko_jarvi.htm">
|
||||
Jaakko Järvi</a>. They were "promoted to <b>boost::</b> status" by <a href="../../people/peter_dimov.htm">
|
||||
Peter Dimov</a> because they are generally useful. <a href="../../people/doug_gregor.html">
|
||||
Douglas Gregor</a> and <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>
|
||||
contributed <tt>is_reference_wrapper</tt> and <tt>unwrap_reference</tt>.
|
||||
</p>
|
||||
<p><br>
|
||||
<br>
|
||||
<br>
|
||||
<small>Copyright © 2001 by Peter Dimov and Multi Media Ltd. Permission to
|
||||
copy, use, modify, sell and distribute this document is granted provided this
|
||||
copyright notice appears in all copies. This document is provided "as
|
||||
is" without express or implied warranty, and with no claim as to its
|
||||
suitability for any purpose.</small></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
25
test/Jamfile
25
test/Jamfile
@@ -1,25 +0,0 @@
|
||||
# Boost.Bind Library test Jamfile
|
||||
#
|
||||
# Copyright (c) 2003 Peter Dimov
|
||||
#
|
||||
# Permission to copy, use, modify, sell and distribute this software
|
||||
# is granted provided this copyright notice appears in all copies.
|
||||
# This software is provided "as is" without express or implied
|
||||
# warranty, and with no claim as to its suitability for any purpose.
|
||||
|
||||
subproject libs/bind/test ;
|
||||
|
||||
# bring in rules for testing
|
||||
import testing ;
|
||||
|
||||
# Make tests run by default.
|
||||
DEPENDS all : bind ;
|
||||
|
||||
{
|
||||
test-suite "bind"
|
||||
: [ run bind_test.cpp ]
|
||||
[ run mem_fn_test.cpp ]
|
||||
[ run mem_fn_void_test.cpp ]
|
||||
[ run mem_fn_derived_test.cpp ]
|
||||
;
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
# Boost.Bind Library test Jamfile
|
||||
#
|
||||
# Copyright (c) 2003 Peter Dimov
|
||||
#
|
||||
# Permission to copy, use, modify, sell and distribute this software
|
||||
# is granted provided this copyright notice appears in all copies.
|
||||
# This software is provided "as is" without express or implied
|
||||
# warranty, and with no claim as to its suitability for any purpose.
|
||||
|
||||
# bring in rules for testing
|
||||
import testing ;
|
||||
|
||||
test-suite "bind"
|
||||
: [ run bind_test.cpp ]
|
||||
[ run mem_fn_test.cpp ]
|
||||
[ run mem_fn_void_test.cpp ]
|
||||
[ run mem_fn_derived_test.cpp ]
|
||||
;
|
||||
|
||||
@@ -1,165 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_stdcall_mf_test.cpp - test for bind.hpp + __stdcall (member functions)
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#define BOOST_MEM_FN_ENABLE_FASTCALL
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
struct X
|
||||
{
|
||||
mutable unsigned int hash;
|
||||
|
||||
X(): hash(0) {}
|
||||
|
||||
void __fastcall f0() { f1(17); }
|
||||
void __fastcall g0() const { g1(17); }
|
||||
|
||||
void __fastcall f1(int a1) { hash = (hash * 17041 + a1) % 32768; }
|
||||
void __fastcall g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; }
|
||||
|
||||
void __fastcall f2(int a1, int a2) { f1(a1); f1(a2); }
|
||||
void __fastcall g2(int a1, int a2) const { g1(a1); g1(a2); }
|
||||
|
||||
void __fastcall f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); }
|
||||
void __fastcall g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); }
|
||||
|
||||
void __fastcall f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); }
|
||||
void __fastcall g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); }
|
||||
|
||||
void __fastcall f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); }
|
||||
void __fastcall g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); }
|
||||
|
||||
void __fastcall f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); }
|
||||
void __fastcall g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); }
|
||||
|
||||
void __fastcall f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); }
|
||||
void __fastcall g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); }
|
||||
|
||||
void __fastcall f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); }
|
||||
void __fastcall g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); }
|
||||
};
|
||||
|
||||
void member_function_test()
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
X x;
|
||||
|
||||
// 0
|
||||
|
||||
bind(&X::f0, &x)();
|
||||
bind(&X::f0, ref(x))();
|
||||
|
||||
bind(&X::g0, &x)();
|
||||
bind(&X::g0, x)();
|
||||
bind(&X::g0, ref(x))();
|
||||
|
||||
// 1
|
||||
|
||||
bind(&X::f1, &x, 1)();
|
||||
bind(&X::f1, ref(x), 1)();
|
||||
|
||||
bind(&X::g1, &x, 1)();
|
||||
bind(&X::g1, x, 1)();
|
||||
bind(&X::g1, ref(x), 1)();
|
||||
|
||||
// 2
|
||||
|
||||
bind(&X::f2, &x, 1, 2)();
|
||||
bind(&X::f2, ref(x), 1, 2)();
|
||||
|
||||
bind(&X::g2, &x, 1, 2)();
|
||||
bind(&X::g2, x, 1, 2)();
|
||||
bind(&X::g2, ref(x), 1, 2)();
|
||||
|
||||
// 3
|
||||
|
||||
bind(&X::f3, &x, 1, 2, 3)();
|
||||
bind(&X::f3, ref(x), 1, 2, 3)();
|
||||
|
||||
bind(&X::g3, &x, 1, 2, 3)();
|
||||
bind(&X::g3, x, 1, 2, 3)();
|
||||
bind(&X::g3, ref(x), 1, 2, 3)();
|
||||
|
||||
// 4
|
||||
|
||||
bind(&X::f4, &x, 1, 2, 3, 4)();
|
||||
bind(&X::f4, ref(x), 1, 2, 3, 4)();
|
||||
|
||||
bind(&X::g4, &x, 1, 2, 3, 4)();
|
||||
bind(&X::g4, x, 1, 2, 3, 4)();
|
||||
bind(&X::g4, ref(x), 1, 2, 3, 4)();
|
||||
|
||||
// 5
|
||||
|
||||
bind(&X::f5, &x, 1, 2, 3, 4, 5)();
|
||||
bind(&X::f5, ref(x), 1, 2, 3, 4, 5)();
|
||||
|
||||
bind(&X::g5, &x, 1, 2, 3, 4, 5)();
|
||||
bind(&X::g5, x, 1, 2, 3, 4, 5)();
|
||||
bind(&X::g5, ref(x), 1, 2, 3, 4, 5)();
|
||||
|
||||
// 6
|
||||
|
||||
bind(&X::f6, &x, 1, 2, 3, 4, 5, 6)();
|
||||
bind(&X::f6, ref(x), 1, 2, 3, 4, 5, 6)();
|
||||
|
||||
bind(&X::g6, &x, 1, 2, 3, 4, 5, 6)();
|
||||
bind(&X::g6, x, 1, 2, 3, 4, 5, 6)();
|
||||
bind(&X::g6, ref(x), 1, 2, 3, 4, 5, 6)();
|
||||
|
||||
// 7
|
||||
|
||||
bind(&X::f7, &x, 1, 2, 3, 4, 5, 6, 7)();
|
||||
bind(&X::f7, ref(x), 1, 2, 3, 4, 5, 6, 7)();
|
||||
|
||||
bind(&X::g7, &x, 1, 2, 3, 4, 5, 6, 7)();
|
||||
bind(&X::g7, x, 1, 2, 3, 4, 5, 6, 7)();
|
||||
bind(&X::g7, ref(x), 1, 2, 3, 4, 5, 6, 7)();
|
||||
|
||||
// 8
|
||||
|
||||
bind(&X::f8, &x, 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
bind(&X::f8, ref(x), 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
|
||||
bind(&X::g8, &x, 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
bind(&X::g8, x, 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
bind(&X::g8, ref(x), 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
|
||||
BOOST_TEST( x.hash == 23558 );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
member_function_test();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,111 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_fastcall_test.cpp - test for bind.hpp + __fastcall (free functions)
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#define BOOST_BIND_ENABLE_FASTCALL
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
//
|
||||
|
||||
long __fastcall f_0()
|
||||
{
|
||||
return 17041L;
|
||||
}
|
||||
|
||||
long __fastcall f_1(long a)
|
||||
{
|
||||
return a;
|
||||
}
|
||||
|
||||
long __fastcall f_2(long a, long b)
|
||||
{
|
||||
return a + 10 * b;
|
||||
}
|
||||
|
||||
long __fastcall f_3(long a, long b, long c)
|
||||
{
|
||||
return a + 10 * b + 100 * c;
|
||||
}
|
||||
|
||||
long __fastcall f_4(long a, long b, long c, long d)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d;
|
||||
}
|
||||
|
||||
long __fastcall f_5(long a, long b, long c, long d, long e)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d + 10000 * e;
|
||||
}
|
||||
|
||||
long __fastcall f_6(long a, long b, long c, long d, long e, long f)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f;
|
||||
}
|
||||
|
||||
long __fastcall f_7(long a, long b, long c, long d, long e, long f, long g)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g;
|
||||
}
|
||||
|
||||
long __fastcall f_8(long a, long b, long c, long d, long e, long f, long g, long h)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h;
|
||||
}
|
||||
|
||||
long __fastcall f_9(long a, long b, long c, long d, long e, long f, long g, long h, long i)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h + 100000000 * i;
|
||||
}
|
||||
|
||||
void function_test()
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
int const i = 1;
|
||||
|
||||
BOOST_TEST( bind(f_0)(i) == 17041L );
|
||||
BOOST_TEST( bind(f_1, _1)(i) == 1L );
|
||||
BOOST_TEST( bind(f_2, _1, 2)(i) == 21L );
|
||||
BOOST_TEST( bind(f_3, _1, 2, 3)(i) == 321L );
|
||||
BOOST_TEST( bind(f_4, _1, 2, 3, 4)(i) == 4321L );
|
||||
BOOST_TEST( bind(f_5, _1, 2, 3, 4, 5)(i) == 54321L );
|
||||
BOOST_TEST( bind(f_6, _1, 2, 3, 4, 5, 6)(i) == 654321L );
|
||||
BOOST_TEST( bind(f_7, _1, 2, 3, 4, 5, 6, 7)(i) == 7654321L );
|
||||
BOOST_TEST( bind(f_8, _1, 2, 3, 4, 5, 6, 7, 8)(i) == 87654321L );
|
||||
BOOST_TEST( bind(f_9, _1, 2, 3, 4, 5, 6, 7, 8, 9)(i) == 987654321L );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
function_test();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,187 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// mem_fn_fastcall_test.cpp - a test for mem_fn.hpp + __fastcall
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#define BOOST_MEM_FN_ENABLE_FASTCALL
|
||||
|
||||
#include <boost/mem_fn.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
|
||||
struct X
|
||||
{
|
||||
mutable unsigned int hash;
|
||||
|
||||
X(): hash(0) {}
|
||||
|
||||
void __fastcall f0() { f1(17); }
|
||||
void __fastcall g0() const { g1(17); }
|
||||
|
||||
void __fastcall f1(int a1) { hash = (hash * 17041 + a1) % 32768; }
|
||||
void __fastcall g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; }
|
||||
|
||||
void __fastcall f2(int a1, int a2) { f1(a1); f1(a2); }
|
||||
void __fastcall g2(int a1, int a2) const { g1(a1); g1(a2); }
|
||||
|
||||
void __fastcall f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); }
|
||||
void __fastcall g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); }
|
||||
|
||||
void __fastcall f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); }
|
||||
void __fastcall g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); }
|
||||
|
||||
void __fastcall f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); }
|
||||
void __fastcall g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); }
|
||||
|
||||
void __fastcall f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); }
|
||||
void __fastcall g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); }
|
||||
|
||||
void __fastcall f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); }
|
||||
void __fastcall g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); }
|
||||
|
||||
void __fastcall f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); }
|
||||
void __fastcall g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); }
|
||||
};
|
||||
|
||||
int detect_errors(bool x)
|
||||
{
|
||||
if(x)
|
||||
{
|
||||
std::cerr << "no errors detected.\n";
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cerr << "test failed.\n";
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
using boost::mem_fn;
|
||||
|
||||
X x;
|
||||
|
||||
X const & rcx = x;
|
||||
X const * pcx = &x;
|
||||
|
||||
boost::shared_ptr<X> sp(new X);
|
||||
|
||||
mem_fn(&X::f0)(x);
|
||||
mem_fn(&X::f0)(&x);
|
||||
mem_fn(&X::f0)(sp);
|
||||
|
||||
mem_fn(&X::g0)(x);
|
||||
mem_fn(&X::g0)(rcx);
|
||||
mem_fn(&X::g0)(&x);
|
||||
mem_fn(&X::g0)(pcx);
|
||||
mem_fn(&X::g0)(sp);
|
||||
|
||||
mem_fn(&X::f1)(x, 1);
|
||||
mem_fn(&X::f1)(&x, 1);
|
||||
mem_fn(&X::f1)(sp, 1);
|
||||
|
||||
mem_fn(&X::g1)(x, 1);
|
||||
mem_fn(&X::g1)(rcx, 1);
|
||||
mem_fn(&X::g1)(&x, 1);
|
||||
mem_fn(&X::g1)(pcx, 1);
|
||||
mem_fn(&X::g1)(sp, 1);
|
||||
|
||||
mem_fn(&X::f2)(x, 1, 2);
|
||||
mem_fn(&X::f2)(&x, 1, 2);
|
||||
mem_fn(&X::f2)(sp, 1, 2);
|
||||
|
||||
mem_fn(&X::g2)(x, 1, 2);
|
||||
mem_fn(&X::g2)(rcx, 1, 2);
|
||||
mem_fn(&X::g2)(&x, 1, 2);
|
||||
mem_fn(&X::g2)(pcx, 1, 2);
|
||||
mem_fn(&X::g2)(sp, 1, 2);
|
||||
|
||||
mem_fn(&X::f3)(x, 1, 2, 3);
|
||||
mem_fn(&X::f3)(&x, 1, 2, 3);
|
||||
mem_fn(&X::f3)(sp, 1, 2, 3);
|
||||
|
||||
mem_fn(&X::g3)(x, 1, 2, 3);
|
||||
mem_fn(&X::g3)(rcx, 1, 2, 3);
|
||||
mem_fn(&X::g3)(&x, 1, 2, 3);
|
||||
mem_fn(&X::g3)(pcx, 1, 2, 3);
|
||||
mem_fn(&X::g3)(sp, 1, 2, 3);
|
||||
|
||||
mem_fn(&X::f4)(x, 1, 2, 3, 4);
|
||||
mem_fn(&X::f4)(&x, 1, 2, 3, 4);
|
||||
mem_fn(&X::f4)(sp, 1, 2, 3, 4);
|
||||
|
||||
mem_fn(&X::g4)(x, 1, 2, 3, 4);
|
||||
mem_fn(&X::g4)(rcx, 1, 2, 3, 4);
|
||||
mem_fn(&X::g4)(&x, 1, 2, 3, 4);
|
||||
mem_fn(&X::g4)(pcx, 1, 2, 3, 4);
|
||||
mem_fn(&X::g4)(sp, 1, 2, 3, 4);
|
||||
|
||||
mem_fn(&X::f5)(x, 1, 2, 3, 4, 5);
|
||||
mem_fn(&X::f5)(&x, 1, 2, 3, 4, 5);
|
||||
mem_fn(&X::f5)(sp, 1, 2, 3, 4, 5);
|
||||
|
||||
mem_fn(&X::g5)(x, 1, 2, 3, 4, 5);
|
||||
mem_fn(&X::g5)(rcx, 1, 2, 3, 4, 5);
|
||||
mem_fn(&X::g5)(&x, 1, 2, 3, 4, 5);
|
||||
mem_fn(&X::g5)(pcx, 1, 2, 3, 4, 5);
|
||||
mem_fn(&X::g5)(sp, 1, 2, 3, 4, 5);
|
||||
|
||||
mem_fn(&X::f6)(x, 1, 2, 3, 4, 5, 6);
|
||||
mem_fn(&X::f6)(&x, 1, 2, 3, 4, 5, 6);
|
||||
mem_fn(&X::f6)(sp, 1, 2, 3, 4, 5, 6);
|
||||
|
||||
mem_fn(&X::g6)(x, 1, 2, 3, 4, 5, 6);
|
||||
mem_fn(&X::g6)(rcx, 1, 2, 3, 4, 5, 6);
|
||||
mem_fn(&X::g6)(&x, 1, 2, 3, 4, 5, 6);
|
||||
mem_fn(&X::g6)(pcx, 1, 2, 3, 4, 5, 6);
|
||||
mem_fn(&X::g6)(sp, 1, 2, 3, 4, 5, 6);
|
||||
|
||||
mem_fn(&X::f7)(x, 1, 2, 3, 4, 5, 6, 7);
|
||||
mem_fn(&X::f7)(&x, 1, 2, 3, 4, 5, 6, 7);
|
||||
mem_fn(&X::f7)(sp, 1, 2, 3, 4, 5, 6, 7);
|
||||
|
||||
mem_fn(&X::g7)(x, 1, 2, 3, 4, 5, 6, 7);
|
||||
mem_fn(&X::g7)(rcx, 1, 2, 3, 4, 5, 6, 7);
|
||||
mem_fn(&X::g7)(&x, 1, 2, 3, 4, 5, 6, 7);
|
||||
mem_fn(&X::g7)(pcx, 1, 2, 3, 4, 5, 6, 7);
|
||||
mem_fn(&X::g7)(sp, 1, 2, 3, 4, 5, 6, 7);
|
||||
|
||||
mem_fn(&X::f8)(x, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
mem_fn(&X::f8)(&x, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
mem_fn(&X::f8)(sp, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
|
||||
mem_fn(&X::g8)(x, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
mem_fn(&X::g8)(rcx, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
mem_fn(&X::g8)(&x, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
mem_fn(&X::g8)(pcx, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
mem_fn(&X::g8)(sp, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
|
||||
return detect_errors(x.hash == 17610 && sp->hash == 2155);
|
||||
}
|
||||
Reference in New Issue
Block a user