mirror of
https://github.com/boostorg/bind.git
synced 2026-04-13 21:25:59 +02:00
Compare commits
5 Commits
boost-1.32
...
boost-1.30
| Author | SHA1 | Date | |
|---|---|---|---|
|
85115dffd8 | ||
|
|
757d0122de | ||
|
3a80081642 | ||
|
b32ebea99c | ||
|
|
5454a5aac6 |
@@ -7,7 +7,7 @@
|
||||
<body style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%" bgColor="white">
|
||||
<table width="100%" border="0">
|
||||
<tr>
|
||||
<td width="277"><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277">
|
||||
<td width="277"><IMG height="86" alt="c++boost.gif (8819 bytes)" src="../../c++boost.gif" width="277">
|
||||
</td>
|
||||
<td align="middle">
|
||||
<h1>bind.hpp</h1>
|
||||
@@ -356,8 +356,8 @@ template<class T> void f(T const & t);
|
||||
(b) does not actually work for const arguments, both l- and r-values, since the
|
||||
two templates produce the exact same signature and cannot be partially ordered.
|
||||
</p>
|
||||
<p>[Note: this is a dark corner of the language, and the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#214">
|
||||
corresponding issue</a> has only recently been resolved.]
|
||||
<p>[Note: this is a dark corner of the language, and the <a href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/cwg_active.html#214">
|
||||
corresponding issue</a> has not been resolved yet.]
|
||||
</p>
|
||||
<h2><a name="FAQ">Frequently Asked Questions</a></h2>
|
||||
<h3><a name="Q_doesnt_compile">Why doesn't this compile?</a></h3>
|
||||
@@ -833,7 +833,7 @@ namespace
|
||||
STL</a> by Petter Urkedal.</li></ul>
|
||||
<p>Doug Gregor suggested that a visitor mechanism would allow <b>bind</b> to
|
||||
interoperate with a signal/slot library.</p>
|
||||
<p>John Maddock fixed a MSVC-specific conflict between <b>bind</b> and the <A href="../type_traits/index.html">
|
||||
<p>John Maddock fixed a MSVC-specific conflict between <b>bind</b> and the <A href="../type_traits/index.htm">
|
||||
type traits library</A>.</p>
|
||||
<p>Numerous improvements were suggested during the formal review period by Ross
|
||||
Smith, Richard Crossley, Jens Maurer, Ed Brey, and others. Review manager was
|
||||
|
||||
@@ -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
|
||||
@@ -14,9 +12,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
@@ -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
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
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="type"><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,21 +1,20 @@
|
||||
#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
|
||||
|
||||
//
|
||||
// bind.hpp - binds function objects to arguments
|
||||
//
|
||||
// Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2001 David Abrahams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/bind.html for documentation.
|
||||
//
|
||||
@@ -25,7 +24,6 @@
|
||||
#include <boost/mem_fn.hpp>
|
||||
#include <boost/type.hpp>
|
||||
#include <boost/bind/arg.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
// Borland-specific bug, visit_each() silently fails to produce code
|
||||
|
||||
@@ -69,18 +67,6 @@ template<class F> struct result_traits< unspecified, reference_wrapper<F> >
|
||||
|
||||
#endif
|
||||
|
||||
// ref_compare
|
||||
|
||||
template<class T> bool ref_compare(T const & a, T const & b, long)
|
||||
{
|
||||
return a == b;
|
||||
}
|
||||
|
||||
template<class T> bool ref_compare(reference_wrapper<T> const & a, reference_wrapper<T> const & b, int)
|
||||
{
|
||||
return a.get_pointer() == b.get_pointer();
|
||||
}
|
||||
|
||||
// bind_t forward declaration for listN
|
||||
|
||||
template<class R, class F, class L> class bind_t;
|
||||
@@ -96,11 +82,6 @@ public:
|
||||
T & get() { return t_; }
|
||||
T const & get() const { return t_; }
|
||||
|
||||
bool operator==(value const & rhs) const
|
||||
{
|
||||
return t_ == rhs.t_;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
T t_;
|
||||
@@ -112,41 +93,38 @@ template<class T> class type {};
|
||||
|
||||
// unwrap
|
||||
|
||||
template<class F> inline F & unwrap(F * f, long)
|
||||
template<class F> inline F & unwrap(F & f, long)
|
||||
{
|
||||
return *f;
|
||||
return f;
|
||||
}
|
||||
|
||||
template<class F> inline F & unwrap(reference_wrapper<F> * f, int)
|
||||
template<class F> inline F & unwrap(reference_wrapper<F> & f, int)
|
||||
{
|
||||
return f->get();
|
||||
return f;
|
||||
}
|
||||
|
||||
template<class F> inline F & unwrap(reference_wrapper<F> const * f, int)
|
||||
template<class F> inline F & unwrap(reference_wrapper<F> const & f, int)
|
||||
{
|
||||
return f->get();
|
||||
return f;
|
||||
}
|
||||
|
||||
#if !( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, <= 0x3003) )
|
||||
|
||||
template<class R, class T> inline _mfi::dm<R, T> unwrap(R T::* * pm, int)
|
||||
{
|
||||
return _mfi::dm<R, T>(*pm);
|
||||
}
|
||||
|
||||
#if !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
|
||||
// IBM/VisualAge 6.0 is not able to handle this overload.
|
||||
template<class R, class T> inline _mfi::dm<R, T> unwrap(R T::* const * pm, int)
|
||||
{
|
||||
return _mfi::dm<R, T>(*pm);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
// listN
|
||||
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
|
||||
template <class R> struct evaluator0;
|
||||
template <class R> struct evaluator1;
|
||||
template <class R> struct evaluator2;
|
||||
template <class R> struct evaluator3;
|
||||
template <class R> struct evaluator4;
|
||||
template <class R> struct evaluator5;
|
||||
template <class R> struct evaluator6;
|
||||
template <class R> struct evaluator7;
|
||||
template <class R> struct evaluator8;
|
||||
template <class R> struct evaluator9;
|
||||
|
||||
#endif
|
||||
|
||||
class list0
|
||||
{
|
||||
public:
|
||||
@@ -163,34 +141,24 @@ 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 &, long)
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A &) const
|
||||
{
|
||||
return unwrap(&f, 0)();
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
|
||||
{
|
||||
return unwrap(&f, 0)();
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F & f, A &, int)
|
||||
{
|
||||
unwrap(&f, 0)();
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
|
||||
{
|
||||
unwrap(&f, 0)();
|
||||
return unwrap(f, 0)();
|
||||
}
|
||||
|
||||
template<class V> void accept(V &) const
|
||||
{
|
||||
}
|
||||
|
||||
bool operator==(list0 const &) const
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
|
||||
template<class R> struct evaluator
|
||||
{
|
||||
return true;
|
||||
}
|
||||
typedef evaluator0<R> type;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
};
|
||||
|
||||
template<class A1> class list1
|
||||
@@ -213,24 +181,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, long)
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
|
||||
{
|
||||
return unwrap(&f, 0)(a[a1_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
|
||||
{
|
||||
return unwrap(&f, 0)(a[a1_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_]);
|
||||
return unwrap(f, 0)(a[a1_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -238,13 +191,19 @@ public:
|
||||
BOOST_BIND_VISIT_EACH(v, a1_, 0);
|
||||
}
|
||||
|
||||
bool operator==(list1 const & rhs) const
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
|
||||
template<class R> struct evaluator
|
||||
{
|
||||
return ref_compare(a1_, rhs.a1_, 0);
|
||||
}
|
||||
typedef evaluator1<R> type;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
private:
|
||||
|
||||
#endif
|
||||
|
||||
A1 a1_;
|
||||
};
|
||||
|
||||
@@ -270,24 +229,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, long)
|
||||
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
|
||||
{
|
||||
return unwrap(&f, 0)(a[a1_], a[a2_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
|
||||
{
|
||||
return unwrap(&f, 0)(a[a1_], a[a2_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_]);
|
||||
return unwrap(f, 0)(a[a1_], a[a2_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -296,13 +240,19 @@ public:
|
||||
BOOST_BIND_VISIT_EACH(v, a2_, 0);
|
||||
}
|
||||
|
||||
bool operator==(list2 const & rhs) const
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
|
||||
template<class R> struct evaluator
|
||||
{
|
||||
return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0);
|
||||
}
|
||||
typedef evaluator2<R> type;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
private:
|
||||
|
||||
#endif
|
||||
|
||||
A1 a1_;
|
||||
A2 a2_;
|
||||
};
|
||||
@@ -331,24 +281,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, long)
|
||||
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_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
|
||||
{
|
||||
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]);
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -358,13 +293,19 @@ public:
|
||||
BOOST_BIND_VISIT_EACH(v, a3_, 0);
|
||||
}
|
||||
|
||||
bool operator==(list3 const & rhs) const
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
|
||||
template<class R> struct evaluator
|
||||
{
|
||||
return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0);
|
||||
}
|
||||
typedef evaluator3<R> type;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
private:
|
||||
|
||||
#endif
|
||||
|
||||
A1 a1_;
|
||||
A2 a2_;
|
||||
A3 a3_;
|
||||
@@ -396,24 +337,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, long)
|
||||
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_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
|
||||
{
|
||||
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -424,15 +350,19 @@ public:
|
||||
BOOST_BIND_VISIT_EACH(v, a4_, 0);
|
||||
}
|
||||
|
||||
bool operator==(list4 const & rhs) const
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
|
||||
template<class R> struct evaluator
|
||||
{
|
||||
return
|
||||
ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
|
||||
ref_compare(a4_, rhs.a4_, 0);
|
||||
}
|
||||
typedef evaluator4<R> type;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
private:
|
||||
|
||||
#endif
|
||||
|
||||
A1 a1_;
|
||||
A2 a2_;
|
||||
A3 a3_;
|
||||
@@ -467,24 +397,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, long)
|
||||
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_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
|
||||
{
|
||||
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -496,15 +411,19 @@ public:
|
||||
BOOST_BIND_VISIT_EACH(v, a5_, 0);
|
||||
}
|
||||
|
||||
bool operator==(list5 const & rhs) const
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
|
||||
template<class R> struct evaluator
|
||||
{
|
||||
return
|
||||
ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
|
||||
ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0);
|
||||
}
|
||||
typedef evaluator5<R> type;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
private:
|
||||
|
||||
#endif
|
||||
|
||||
A1 a1_;
|
||||
A2 a2_;
|
||||
A3 a3_;
|
||||
@@ -542,24 +461,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, long)
|
||||
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_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
|
||||
{
|
||||
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -572,15 +476,19 @@ public:
|
||||
BOOST_BIND_VISIT_EACH(v, a6_, 0);
|
||||
}
|
||||
|
||||
bool operator==(list6 const & rhs) const
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
|
||||
template<class R> struct evaluator
|
||||
{
|
||||
return
|
||||
ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
|
||||
ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0);
|
||||
}
|
||||
typedef evaluator6<R> type;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
private:
|
||||
|
||||
#endif
|
||||
|
||||
A1 a1_;
|
||||
A2 a2_;
|
||||
A3 a3_;
|
||||
@@ -621,24 +529,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, long)
|
||||
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_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
|
||||
{
|
||||
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -652,16 +545,19 @@ public:
|
||||
BOOST_BIND_VISIT_EACH(v, a7_, 0);
|
||||
}
|
||||
|
||||
bool operator==(list7 const & rhs) const
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
|
||||
template<class R> struct evaluator
|
||||
{
|
||||
return
|
||||
ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
|
||||
ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0) &&
|
||||
ref_compare(a7_, rhs.a7_, 0);
|
||||
}
|
||||
typedef evaluator7<R> type;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
private:
|
||||
|
||||
#endif
|
||||
|
||||
A1 a1_;
|
||||
A2 a2_;
|
||||
A3 a3_;
|
||||
@@ -705,24 +601,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, long)
|
||||
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_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
|
||||
{
|
||||
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
|
||||
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -737,16 +618,19 @@ public:
|
||||
BOOST_BIND_VISIT_EACH(v, a8_, 0);
|
||||
}
|
||||
|
||||
bool operator==(list8 const & rhs) const
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
|
||||
template<class R> struct evaluator
|
||||
{
|
||||
return
|
||||
ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
|
||||
ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0) &&
|
||||
ref_compare(a7_, rhs.a7_, 0) && ref_compare(a8_, rhs.a8_, 0);
|
||||
}
|
||||
typedef evaluator8<R> type;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
private:
|
||||
|
||||
#endif
|
||||
|
||||
A1 a1_;
|
||||
A2 a2_;
|
||||
A3 a3_;
|
||||
@@ -793,24 +677,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, long)
|
||||
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_]);
|
||||
}
|
||||
|
||||
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
|
||||
{
|
||||
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
|
||||
}
|
||||
|
||||
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
|
||||
{
|
||||
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
|
||||
return unwrap(f, 0)(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
|
||||
@@ -826,16 +695,19 @@ public:
|
||||
BOOST_BIND_VISIT_EACH(v, a9_, 0);
|
||||
}
|
||||
|
||||
bool operator==(list9 const & rhs) const
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
|
||||
template<class R> struct evaluator
|
||||
{
|
||||
return
|
||||
ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
|
||||
ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0) &&
|
||||
ref_compare(a7_, rhs.a7_, 0) && ref_compare(a8_, rhs.a8_, 0) && ref_compare(a9_, rhs.a9_, 0);
|
||||
}
|
||||
typedef evaluator9<R> type;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
private:
|
||||
|
||||
#endif
|
||||
|
||||
A1 a1_;
|
||||
A2 a2_;
|
||||
A3 a3_;
|
||||
@@ -847,6 +719,190 @@ private:
|
||||
A9 a9_;
|
||||
};
|
||||
|
||||
#ifdef BOOST_NO_VOID_RETURNS
|
||||
|
||||
template <class R> struct evaluator0
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L const&, F f, A &)
|
||||
{
|
||||
return unwrap(f, 0)();
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator0<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L const&, F f, A &)
|
||||
{
|
||||
unwrap(f, 0)();
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator1
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[l.a1_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator1<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(a[l.a1_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator2
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[l.a1_], a[l.a2_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator2<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(a[l.a1_], a[l.a2_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator3
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static R eval(L const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator3<void>
|
||||
{
|
||||
template<class L, class F, class A>
|
||||
static void eval(L const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(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 const& l, F f, A & a)
|
||||
{
|
||||
return unwrap(f, 0)(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 const& l, F f, A & a)
|
||||
{
|
||||
unwrap(f, 0)(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 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_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator5<void>
|
||||
{
|
||||
template<class L, class F, class 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_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator6
|
||||
{
|
||||
template<class L, class F, class 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_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator6<void>
|
||||
{
|
||||
template<class L, class F, class 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_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator7
|
||||
{
|
||||
template<class L, class F, class 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_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator7<void>
|
||||
{
|
||||
template<class L, class F, class 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_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator8
|
||||
{
|
||||
template<class L, class F, class 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_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator8<void>
|
||||
{
|
||||
template<class L, class F, class 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_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <class R> struct evaluator9
|
||||
{
|
||||
template<class L, class F, class 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_]);
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct evaluator9<void>
|
||||
{
|
||||
template<class L, class F, class 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_]);
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
// bind_t
|
||||
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
@@ -855,13 +911,11 @@ template<class R, class F, class L> class bind_t
|
||||
{
|
||||
public:
|
||||
|
||||
typedef bind_t this_type;
|
||||
|
||||
bind_t(F f, L const & l): f_(f), l_(l) {}
|
||||
|
||||
#define BOOST_BIND_RETURN return
|
||||
#define BOOST_BIND_EVALUATE return l_(type<result_type>(), f_, a)
|
||||
#include <boost/bind/bind_template.hpp>
|
||||
#undef BOOST_BIND_RETURN
|
||||
#undef BOOST_BIND_EVALUATE
|
||||
|
||||
};
|
||||
|
||||
@@ -874,13 +928,11 @@ template<class F, class L> class implementation
|
||||
{
|
||||
public:
|
||||
|
||||
typedef implementation this_type;
|
||||
|
||||
implementation(F f, L const & l): f_(f), l_(l) {}
|
||||
|
||||
#define BOOST_BIND_RETURN return
|
||||
#define BOOST_BIND_EVALUATE return L::BOOST_NESTED_TEMPLATE evaluator<result_type>::type::eval(l_, f_, a);
|
||||
#include <boost/bind/bind_template.hpp>
|
||||
#undef BOOST_BIND_RETURN
|
||||
#undef BOOST_BIND_EVALUATE
|
||||
|
||||
};
|
||||
|
||||
@@ -897,13 +949,11 @@ private:
|
||||
|
||||
public:
|
||||
|
||||
typedef implementation this_type;
|
||||
|
||||
implementation(F f, L const & l): f_(f), l_(l) {}
|
||||
|
||||
#define BOOST_BIND_RETURN
|
||||
#define BOOST_BIND_EVALUATE L::BOOST_NESTED_TEMPLATE evaluator<result_type>::type::eval(l_, f_, a);
|
||||
#include <boost/bind/bind_template.hpp>
|
||||
#undef BOOST_BIND_RETURN
|
||||
#undef BOOST_BIND_EVALUATE
|
||||
|
||||
};
|
||||
|
||||
@@ -919,18 +969,6 @@ public:
|
||||
|
||||
#endif
|
||||
|
||||
// bind_t::operator==
|
||||
|
||||
template<class R, class F, class L> bool operator==(bind_t<R, F, L> const & a, bind_t<R, F, L> const & b)
|
||||
{
|
||||
return a.compare(b);
|
||||
}
|
||||
|
||||
template<class R, class F, class L> bool operator!=(bind_t<R, F, L> const & a, bind_t<R, F, L> const & b)
|
||||
{
|
||||
return !a.compare(b);
|
||||
}
|
||||
|
||||
// add_value
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)
|
||||
@@ -1096,6 +1134,18 @@ 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
|
||||
@@ -1448,30 +1498,8 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl
|
||||
|
||||
// data member pointers
|
||||
|
||||
/*
|
||||
|
||||
#if defined(__GNUC__) && (__GNUC__ == 2)
|
||||
|
||||
namespace _bi
|
||||
{
|
||||
|
||||
template<class T> struct add_cref
|
||||
{
|
||||
typedef T const & type;
|
||||
};
|
||||
|
||||
template<class T> struct add_cref< T & >
|
||||
{
|
||||
typedef T const & type;
|
||||
};
|
||||
|
||||
template<> struct add_cref<void>
|
||||
{
|
||||
typedef void type;
|
||||
};
|
||||
|
||||
} // namespace _bi
|
||||
|
||||
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 >
|
||||
BOOST_BIND(R T::*f, A1 a1)
|
||||
@@ -1494,17 +1522,6 @@ _bi::bind_t< R const &, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
|
||||
|
||||
#endif
|
||||
|
||||
*/
|
||||
|
||||
template<class R, class T, class A1>
|
||||
_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<R, F, list_type>( F(f), list_type(a1) );
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#ifndef BOOST_BIND_NO_PLACEHOLDERS
|
||||
|
||||
@@ -4,11 +4,12 @@
|
||||
//
|
||||
// apply.hpp
|
||||
//
|
||||
// Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
|
||||
namespace boost
|
||||
@@ -18,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
|
||||
|
||||
//
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/bind.html for documentation.
|
||||
//
|
||||
@@ -26,11 +25,6 @@ template<int I> class arg
|
||||
{
|
||||
};
|
||||
|
||||
template<int I> bool operator==(arg<I> const &, arg<I> const &)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // #ifndef BOOST_BIND_ARG_HPP_INCLUDED
|
||||
|
||||
@@ -5,9 +5,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/bind.html for documentation.
|
||||
//
|
||||
|
||||
@@ -5,9 +5,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/bind.html for documentation.
|
||||
//
|
||||
|
||||
@@ -3,11 +3,12 @@
|
||||
//
|
||||
// Do not include this header directly.
|
||||
//
|
||||
// Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/bind.html for documentation.
|
||||
//
|
||||
@@ -17,131 +18,131 @@
|
||||
result_type operator()()
|
||||
{
|
||||
list0 a;
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
result_type operator()() const
|
||||
{
|
||||
list0 a;
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1> result_type operator()(A1 & a1)
|
||||
{
|
||||
list1<A1 &> a(a1);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1> result_type operator()(A1 & a1) const
|
||||
{
|
||||
list1<A1 &> a(a1);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
|
||||
{
|
||||
list2<A1 &, A2 &> a(a1, a2);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
|
||||
{
|
||||
list2<A1 &, A2 &> a(a1, a2);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
|
||||
{
|
||||
list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
|
||||
{
|
||||
list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
|
||||
{
|
||||
list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
|
||||
{
|
||||
list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
|
||||
{
|
||||
list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
|
||||
{
|
||||
list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
|
||||
{
|
||||
list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
|
||||
{
|
||||
list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
|
||||
{
|
||||
list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
|
||||
{
|
||||
list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
|
||||
{
|
||||
list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
|
||||
{
|
||||
list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
|
||||
{
|
||||
list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
|
||||
{
|
||||
list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A> result_type eval(A & a)
|
||||
{
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A> result_type eval(A & a) const
|
||||
{
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -150,11 +151,6 @@
|
||||
l_.accept(v);
|
||||
}
|
||||
|
||||
bool compare(this_type const & rhs) const
|
||||
{
|
||||
return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
F f_;
|
||||
|
||||
@@ -6,9 +6,10 @@
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
|
||||
namespace boost
|
||||
@@ -17,6 +18,10 @@ namespace boost
|
||||
namespace _bi
|
||||
{
|
||||
|
||||
template<class F> void instantiate(F)
|
||||
{
|
||||
}
|
||||
|
||||
template<class R, class F> class af0
|
||||
{
|
||||
public:
|
||||
@@ -32,11 +37,6 @@ public:
|
||||
return f_();
|
||||
}
|
||||
|
||||
result_type operator()() const
|
||||
{
|
||||
return f_();
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
F f_;
|
||||
@@ -59,11 +59,6 @@ public:
|
||||
return f_(a1);
|
||||
}
|
||||
|
||||
result_type operator()(A1 a1) const
|
||||
{
|
||||
return f_(a1);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
F f_;
|
||||
@@ -88,11 +83,6 @@ public:
|
||||
return f_(a1, a2);
|
||||
}
|
||||
|
||||
result_type operator()(A1 a1, A2 a2) const
|
||||
{
|
||||
return f_(a1, a2);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
F f_;
|
||||
@@ -116,11 +106,6 @@ public:
|
||||
return f_(a1, a2, a3);
|
||||
}
|
||||
|
||||
result_type operator()(A1 a1, A2 a2, A3 a3) const
|
||||
{
|
||||
return f_(a1, a2, a3);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
F f_;
|
||||
@@ -145,11 +130,6 @@ public:
|
||||
return f_(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4) const
|
||||
{
|
||||
return f_(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
F f_;
|
||||
@@ -159,26 +139,31 @@ private:
|
||||
|
||||
template<class R, class F> _bi::af0<R, F> make_adaptable(F f)
|
||||
{
|
||||
_bi::instantiate( &_bi::af0<R, F>::operator() ); // for early error detection
|
||||
return _bi::af0<R, F>(f);
|
||||
}
|
||||
|
||||
template<class R, class A1, class F> _bi::af1<R, A1, F> make_adaptable(F f)
|
||||
{
|
||||
instantiate( &_bi::af1<R, A1, F>::operator() );
|
||||
return _bi::af1<R, A1, F>(f);
|
||||
}
|
||||
|
||||
template<class R, class A1, class A2, class F> _bi::af2<R, A1, A2, F> make_adaptable(F f)
|
||||
{
|
||||
instantiate( &_bi::af2<R, A1, A2, F>::operator() );
|
||||
return _bi::af2<R, A1, A2, F>(f);
|
||||
}
|
||||
|
||||
template<class R, class A1, class A2, class A3, class F> _bi::af3<R, A1, A2, A3, F> make_adaptable(F f)
|
||||
{
|
||||
instantiate( &_bi::af3<R, A1, A2, A3, F>::operator() );
|
||||
return _bi::af3<R, A1, A2, A3, F>(f);
|
||||
}
|
||||
|
||||
template<class R, class A1, class A2, class A3, class A4, class F> _bi::af4<R, A1, A2, A3, A4, F> make_adaptable(F f)
|
||||
{
|
||||
instantiate( &_bi::af4<R, A1, A2, A3, A4, F>::operator() );
|
||||
return _bi::af4<R, A1, A2, A3, A4, F>(f);
|
||||
}
|
||||
|
||||
|
||||
@@ -5,9 +5,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
|
||||
//
|
||||
|
||||
@@ -5,9 +5,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
|
||||
//
|
||||
@@ -54,16 +55,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)();
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf0) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf0) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf0
|
||||
@@ -103,16 +94,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)();
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf1
|
||||
@@ -158,16 +139,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf1) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf1) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf1
|
||||
@@ -208,16 +179,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf2
|
||||
@@ -261,16 +222,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf2) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf2) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf2
|
||||
@@ -309,16 +260,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf3
|
||||
@@ -362,16 +303,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf3) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf3) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf3
|
||||
@@ -410,16 +341,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf4
|
||||
@@ -463,16 +384,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf4) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf4) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf4
|
||||
@@ -511,16 +422,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf5
|
||||
@@ -564,16 +465,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf5) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf5) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf5
|
||||
@@ -612,16 +503,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf6
|
||||
@@ -665,16 +546,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf6) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf6) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf6
|
||||
@@ -713,16 +584,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf7
|
||||
@@ -766,16 +627,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf7) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf7) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf7
|
||||
@@ -814,16 +665,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf8
|
||||
@@ -867,16 +708,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf8) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf8) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf8
|
||||
@@ -920,15 +751,5 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -5,9 +5,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
|
||||
//
|
||||
|
||||
@@ -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
|
||||
|
||||
//
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/bind.html for documentation.
|
||||
//
|
||||
@@ -37,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) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__)
|
||||
#elif (defined(BOOST_MSVC) && BOOST_MSVC <= 1300) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__)
|
||||
|
||||
static boost::arg<1> _1;
|
||||
static boost::arg<2> _2;
|
||||
|
||||
@@ -6,9 +6,10 @@
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
|
||||
namespace boost
|
||||
|
||||
@@ -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
|
||||
|
||||
//
|
||||
@@ -13,16 +11,16 @@
|
||||
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2001 David Abrahams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
|
||||
//
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/get_pointer.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
@@ -294,7 +292,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
|
||||
{
|
||||
@@ -307,16 +305,6 @@ public:
|
||||
{
|
||||
return (t.*f_);
|
||||
}
|
||||
|
||||
bool operator==(dm const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(dm const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace _mfi
|
||||
|
||||
10
test/Jamfile
10
test/Jamfile
@@ -1,6 +1,6 @@
|
||||
# Boost.Bind Library test Jamfile
|
||||
#
|
||||
# Copyright (c) 2003, 2004 Peter Dimov
|
||||
# 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.
|
||||
@@ -10,7 +10,8 @@
|
||||
subproject libs/bind/test ;
|
||||
|
||||
# bring in rules for testing
|
||||
import testing ;
|
||||
SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
|
||||
include testing.jam ;
|
||||
|
||||
# Make tests run by default.
|
||||
DEPENDS all : bind ;
|
||||
@@ -18,13 +19,8 @@ DEPENDS all : bind ;
|
||||
{
|
||||
test-suite "bind"
|
||||
: [ run bind_test.cpp ]
|
||||
[ run bind_eq_test.cpp ]
|
||||
[ run bind_const_test.cpp ]
|
||||
[ run bind_cv_test.cpp ]
|
||||
[ run bind_stateful_test.cpp ]
|
||||
[ run mem_fn_test.cpp ]
|
||||
[ run mem_fn_void_test.cpp ]
|
||||
[ run mem_fn_derived_test.cpp ]
|
||||
[ run mem_fn_eq_test.cpp ]
|
||||
;
|
||||
}
|
||||
|
||||
@@ -1,24 +0,0 @@
|
||||
# Boost.Bind Library test Jamfile
|
||||
#
|
||||
# Copyright (c) 2003, 2004 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 bind_eq_test.cpp ]
|
||||
[ run bind_const_test.cpp ]
|
||||
[ run bind_cv_test.cpp ]
|
||||
[ run bind_stateful_test.cpp ]
|
||||
[ run mem_fn_test.cpp ]
|
||||
[ run mem_fn_void_test.cpp ]
|
||||
[ run mem_fn_derived_test.cpp ]
|
||||
[ run mem_fn_eq_test.cpp ]
|
||||
;
|
||||
|
||||
@@ -1,184 +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_const_test.cpp - test const bind objects
|
||||
//
|
||||
// Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2001 David Abrahams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
#include <boost/ref.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 f_0()
|
||||
{
|
||||
return 17041L;
|
||||
}
|
||||
|
||||
long f_1(long a)
|
||||
{
|
||||
return a;
|
||||
}
|
||||
|
||||
long f_2(long a, long b)
|
||||
{
|
||||
return a + 10 * b;
|
||||
}
|
||||
|
||||
long f_3(long a, long b, long c)
|
||||
{
|
||||
return a + 10 * b + 100 * c;
|
||||
}
|
||||
|
||||
long f_4(long a, long b, long c, long d)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d;
|
||||
}
|
||||
|
||||
long f_5(long a, long b, long c, long d, long e)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d + 10000 * e;
|
||||
}
|
||||
|
||||
long 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 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 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 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;
|
||||
}
|
||||
|
||||
long global_result;
|
||||
|
||||
void fv_0()
|
||||
{
|
||||
global_result = 17041L;
|
||||
}
|
||||
|
||||
void fv_1(long a)
|
||||
{
|
||||
global_result = a;
|
||||
}
|
||||
|
||||
void fv_2(long a, long b)
|
||||
{
|
||||
global_result = a + 10 * b;
|
||||
}
|
||||
|
||||
void fv_3(long a, long b, long c)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c;
|
||||
}
|
||||
|
||||
void fv_4(long a, long b, long c, long d)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c + 1000 * d;
|
||||
}
|
||||
|
||||
void fv_5(long a, long b, long c, long d, long e)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e;
|
||||
}
|
||||
|
||||
void fv_6(long a, long b, long c, long d, long e, long f)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f;
|
||||
}
|
||||
|
||||
void fv_7(long a, long b, long c, long d, long e, long f, long g)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g;
|
||||
}
|
||||
|
||||
void fv_8(long a, long b, long c, long d, long e, long f, long g, long h)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h;
|
||||
}
|
||||
|
||||
void fv_9(long a, long b, long c, long d, long e, long f, long g, long h, long i)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h + 100000000 * i;
|
||||
}
|
||||
|
||||
template<class F, class A> long test(F const & f, A const & a)
|
||||
{
|
||||
return f(a);
|
||||
}
|
||||
|
||||
template<class F, class A> long testv(F const & f, A const & a)
|
||||
{
|
||||
f(a);
|
||||
return global_result;
|
||||
}
|
||||
|
||||
void function_test()
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
int const i = 1;
|
||||
|
||||
BOOST_TEST( test( bind(f_0), i ) == 17041L );
|
||||
BOOST_TEST( test( bind(f_1, _1), i ) == 1L );
|
||||
BOOST_TEST( test( bind(f_2, _1, 2), i ) == 21L );
|
||||
BOOST_TEST( test( bind(f_3, _1, 2, 3), i ) == 321L );
|
||||
BOOST_TEST( test( bind(f_4, _1, 2, 3, 4), i ) == 4321L );
|
||||
BOOST_TEST( test( bind(f_5, _1, 2, 3, 4, 5), i ) == 54321L );
|
||||
BOOST_TEST( test( bind(f_6, _1, 2, 3, 4, 5, 6), i ) == 654321L );
|
||||
BOOST_TEST( test( bind(f_7, _1, 2, 3, 4, 5, 6, 7), i ) == 7654321L );
|
||||
BOOST_TEST( test( bind(f_8, _1, 2, 3, 4, 5, 6, 7, 8), i ) == 87654321L );
|
||||
BOOST_TEST( test( bind(f_9, _1, 2, 3, 4, 5, 6, 7, 8, 9), i ) == 987654321L );
|
||||
|
||||
BOOST_TEST( testv( bind(fv_0), i ) == 17041L );
|
||||
BOOST_TEST( testv( bind(fv_1, _1), i ) == 1L );
|
||||
BOOST_TEST( testv( bind(fv_2, _1, 2), i ) == 21L );
|
||||
BOOST_TEST( testv( bind(fv_3, _1, 2, 3), i ) == 321L );
|
||||
BOOST_TEST( testv( bind(fv_4, _1, 2, 3, 4), i ) == 4321L );
|
||||
BOOST_TEST( testv( bind(fv_5, _1, 2, 3, 4, 5), i ) == 54321L );
|
||||
BOOST_TEST( testv( bind(fv_6, _1, 2, 3, 4, 5, 6), i ) == 654321L );
|
||||
BOOST_TEST( testv( bind(fv_7, _1, 2, 3, 4, 5, 6, 7), i ) == 7654321L );
|
||||
BOOST_TEST( testv( bind(fv_8, _1, 2, 3, 4, 5, 6, 7, 8), i ) == 87654321L );
|
||||
BOOST_TEST( testv( bind(fv_9, _1, 2, 3, 4, 5, 6, 7, 8, 9), i ) == 987654321L );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
function_test();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,158 +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_cv_test.cpp
|
||||
//
|
||||
// Copyright (c) 2004 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#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
|
||||
{
|
||||
int operator()()
|
||||
{
|
||||
return 17041;
|
||||
}
|
||||
|
||||
int operator()() const
|
||||
{
|
||||
return -17041;
|
||||
}
|
||||
|
||||
int operator()(int x1)
|
||||
{
|
||||
return x1;
|
||||
}
|
||||
|
||||
int operator()(int x1) const
|
||||
{
|
||||
return -x1;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2)
|
||||
{
|
||||
return x1+x2;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2) const
|
||||
{
|
||||
return -(x1+x2);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3)
|
||||
{
|
||||
return x1+x2+x3;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3) const
|
||||
{
|
||||
return -(x1+x2+x3);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4)
|
||||
{
|
||||
return x1+x2+x3+x4;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4) const
|
||||
{
|
||||
return -(x1+x2+x3+x4);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5)
|
||||
{
|
||||
return x1+x2+x3+x4+x5;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5) const
|
||||
{
|
||||
return -(x1+x2+x3+x4+x5);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6)
|
||||
{
|
||||
return x1+x2+x3+x4+x5+x6;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6) const
|
||||
{
|
||||
return -(x1+x2+x3+x4+x5+x6);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7)
|
||||
{
|
||||
return x1+x2+x3+x4+x5+x6+x7;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7) const
|
||||
{
|
||||
return -(x1+x2+x3+x4+x5+x6+x7);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8)
|
||||
{
|
||||
return x1+x2+x3+x4+x5+x6+x7+x8;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8) const
|
||||
{
|
||||
return -(x1+x2+x3+x4+x5+x6+x7+x8);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9)
|
||||
{
|
||||
return x1+x2+x3+x4+x5+x6+x7+x8+x9;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9) const
|
||||
{
|
||||
return -(x1+x2+x3+x4+x5+x6+x7+x8+x9);
|
||||
}
|
||||
};
|
||||
|
||||
template<class F> void test(F f, int r)
|
||||
{
|
||||
F const & cf = f;
|
||||
BOOST_TEST( cf() == -r );
|
||||
BOOST_TEST( f() == r );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test( boost::bind<int>( X() ), 17041 );
|
||||
test( boost::bind<int>( X(), 1 ), 1 );
|
||||
test( boost::bind<int>( X(), 1, 2 ), 1+2 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3 ), 1+2+3 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4 ), 1+2+3+4 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5 ), 1+2+3+4+5 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6 ), 1+2+3+4+5+6 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7 ), 1+2+3+4+5+6+7 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8 ), 1+2+3+4+5+6+7+8 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8, 9 ), 1+2+3+4+5+6+7+8+9 );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,413 +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_eq_test.cpp - boost::bind equality operator
|
||||
//
|
||||
// Copyright (c) 2004 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
#include <boost/ref.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
|
||||
{
|
||||
int i_;
|
||||
|
||||
explicit X(int i): i_(i)
|
||||
{
|
||||
}
|
||||
|
||||
bool operator==(X const & rhs) const
|
||||
{
|
||||
return i_ == rhs.i_;
|
||||
}
|
||||
};
|
||||
|
||||
// f_*
|
||||
|
||||
int f_0()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_1(X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_2(X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_3(X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_4(X, X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_5(X, X, X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_6(X, X, X, X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_7(X, X, X, X, X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_8(X, X, X, X, X, X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_9(X, X, X, X, X, X, X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// fv_*
|
||||
|
||||
void fv_0()
|
||||
{
|
||||
}
|
||||
|
||||
void fv_1(X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_2(X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_3(X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_4(X, X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_5(X, X, X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_6(X, X, X, X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_7(X, X, X, X, X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_8(X, X, X, X, X, X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_9(X, X, X, X, X, X, X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
template<class F> void test_eq(F f1, F f2)
|
||||
{
|
||||
BOOST_TEST(f1 == f2);
|
||||
BOOST_TEST(!(f1 != f2));
|
||||
}
|
||||
|
||||
template<class F> void test_ne(F f1, F f2)
|
||||
{
|
||||
BOOST_TEST(f1 != f2);
|
||||
BOOST_TEST(!(f1 == f2));
|
||||
}
|
||||
|
||||
// 0
|
||||
|
||||
template<class F> void test_0(F f)
|
||||
{
|
||||
test_eq( boost::bind(f), boost::bind(f) );
|
||||
}
|
||||
|
||||
// 1
|
||||
|
||||
template<class F, class V> void test_1_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1), boost::bind(f, v1) );
|
||||
test_ne( boost::bind(f, v1), boost::bind(f, v2) );
|
||||
}
|
||||
|
||||
template<class F> void test_1(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1), boost::bind(f, _1) );
|
||||
|
||||
test_1_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_1_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 2
|
||||
|
||||
template<class F, class V> void test_2_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1), boost::bind(f, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1), boost::bind(f, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1), boost::bind(f, v2, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_2(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2), boost::bind(f, _1, _2) );
|
||||
|
||||
test_2_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_2_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 3
|
||||
|
||||
template<class F, class V> void test_3_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1), boost::bind(f, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1), boost::bind(f, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1), boost::bind(f, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1), boost::bind(f, v2, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_3(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3), boost::bind(f, _1, _2, _3) );
|
||||
|
||||
test_3_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_3_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 4
|
||||
|
||||
template<class F, class V> void test_4_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_4(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3, _4), boost::bind(f, _1, _2, _3, _4) );
|
||||
|
||||
test_4_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_4_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 5
|
||||
|
||||
template<class F, class V> void test_5_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_5(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3, _4, _5), boost::bind(f, _1, _2, _3, _4, _5) );
|
||||
|
||||
test_5_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_5_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 6
|
||||
|
||||
template<class F, class V> void test_6_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_6(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3, _4, _5, _6), boost::bind(f, _1, _2, _3, _4, _5, _6) );
|
||||
|
||||
test_6_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_6_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 7
|
||||
|
||||
template<class F, class V> void test_7_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_7(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3, _4, _5, _6, _7), boost::bind(f, _1, _2, _3, _4, _5, _6, _7) );
|
||||
|
||||
test_7_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_7_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 8
|
||||
|
||||
template<class F, class V> void test_8_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v2, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1, v1, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_8(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3, _4, _5, _6, _7, _8), boost::bind(f, _1, _2, _3, _4, _5, _6, _7, _8) );
|
||||
|
||||
test_8_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_8_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 9
|
||||
|
||||
template<class F, class V> void test_9_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v2, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v2, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1, v1, v1, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_9(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3, _4, _5, _6, _7, _8, _9), boost::bind(f, _1, _2, _3, _4, _5, _6, _7, _8, _9) );
|
||||
|
||||
test_9_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_9_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// 0
|
||||
|
||||
test_0( f_0 );
|
||||
test_0( fv_0 );
|
||||
|
||||
// 1
|
||||
|
||||
test_1( f_1 );
|
||||
test_1( fv_1 );
|
||||
|
||||
// 2
|
||||
|
||||
test_2( f_2 );
|
||||
test_2( fv_2 );
|
||||
|
||||
// 3
|
||||
|
||||
test_3( f_3 );
|
||||
test_3( fv_3 );
|
||||
|
||||
// 4
|
||||
|
||||
test_4( f_4 );
|
||||
test_4( fv_4 );
|
||||
|
||||
// 5
|
||||
|
||||
test_5( f_5 );
|
||||
test_5( fv_5 );
|
||||
|
||||
// 6
|
||||
|
||||
test_6( f_6 );
|
||||
test_6( fv_6 );
|
||||
|
||||
// 7
|
||||
|
||||
test_7( f_7 );
|
||||
test_7( fv_7 );
|
||||
|
||||
// 8
|
||||
|
||||
test_8( f_8 );
|
||||
test_8( fv_8 );
|
||||
|
||||
// 9
|
||||
|
||||
test_9( f_9 );
|
||||
test_9( fv_9 );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -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
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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
|
||||
|
||||
@@ -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
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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
|
||||
|
||||
@@ -1,222 +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_stateful_test.cpp
|
||||
//
|
||||
// Copyright (c) 2004 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#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>
|
||||
|
||||
class X
|
||||
{
|
||||
private:
|
||||
|
||||
int state_;
|
||||
|
||||
public:
|
||||
|
||||
X(): state_(0)
|
||||
{
|
||||
}
|
||||
|
||||
int state() const
|
||||
{
|
||||
return state_;
|
||||
}
|
||||
|
||||
int operator()()
|
||||
{
|
||||
return state_ += 17041;
|
||||
}
|
||||
|
||||
int operator()(int x1)
|
||||
{
|
||||
return state_ += x1;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2)
|
||||
{
|
||||
return state_ += x1+x2;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3)
|
||||
{
|
||||
return state_ += x1+x2+x3;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6+x7;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6+x7+x8;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6+x7+x8+x9;
|
||||
}
|
||||
};
|
||||
|
||||
int f0(int & state_)
|
||||
{
|
||||
return state_ += 17041;
|
||||
}
|
||||
|
||||
int f1(int & state_, int x1)
|
||||
{
|
||||
return state_ += x1;
|
||||
}
|
||||
|
||||
int f2(int & state_, int x1, int x2)
|
||||
{
|
||||
return state_ += x1+x2;
|
||||
}
|
||||
|
||||
int f3(int & state_, int x1, int x2, int x3)
|
||||
{
|
||||
return state_ += x1+x2+x3;
|
||||
}
|
||||
|
||||
int f4(int & state_, int x1, int x2, int x3, int x4)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4;
|
||||
}
|
||||
|
||||
int f5(int & state_, int x1, int x2, int x3, int x4, int x5)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5;
|
||||
}
|
||||
|
||||
int f6(int & state_, int x1, int x2, int x3, int x4, int x5, int x6)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6;
|
||||
}
|
||||
|
||||
int f7(int & state_, int x1, int x2, int x3, int x4, int x5, int x6, int x7)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6+x7;
|
||||
}
|
||||
|
||||
int f8(int & state_, int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6+x7+x8;
|
||||
}
|
||||
|
||||
template<class F> void test(F f, int a, int b)
|
||||
{
|
||||
BOOST_TEST( f() == a + b );
|
||||
BOOST_TEST( f() == a + 2*b );
|
||||
BOOST_TEST( f() == a + 3*b );
|
||||
}
|
||||
|
||||
void stateful_function_object_test()
|
||||
{
|
||||
test( boost::bind<int>( X() ), 0, 17041 );
|
||||
test( boost::bind<int>( X(), 1 ), 0, 1 );
|
||||
test( boost::bind<int>( X(), 1, 2 ), 0, 1+2 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3 ), 0, 1+2+3 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4 ), 0, 1+2+3+4 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5 ), 0, 1+2+3+4+5 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6 ), 0, 1+2+3+4+5+6 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7 ), 0, 1+2+3+4+5+6+7 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8 ), 0, 1+2+3+4+5+6+7+8 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8, 9 ), 0, 1+2+3+4+5+6+7+8+9 );
|
||||
|
||||
X x;
|
||||
|
||||
int n = x.state();
|
||||
|
||||
test( boost::bind<int>( boost::ref(x) ), n, 17041 );
|
||||
n += 3*17041;
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1 ), n, 1 );
|
||||
n += 3*1;
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2 ), n, 1+2 );
|
||||
n += 3*(1+2);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3 ), n, 1+2+3 );
|
||||
n += 3*(1+2+3);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4 ), n, 1+2+3+4 );
|
||||
n += 3*(1+2+3+4);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5 ), n, 1+2+3+4+5 );
|
||||
n += 3*(1+2+3+4+5);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6 ), n, 1+2+3+4+5+6 );
|
||||
n += 3*(1+2+3+4+5+6);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6, 7 ), n, 1+2+3+4+5+6+7 );
|
||||
n += 3*(1+2+3+4+5+6+7);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6, 7, 8 ), n, 1+2+3+4+5+6+7+8 );
|
||||
n += 3*(1+2+3+4+5+6+7+8);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6, 7, 8, 9 ), n, 1+2+3+4+5+6+7+8+9 );
|
||||
n += 3*(1+2+3+4+5+6+7+8+9);
|
||||
|
||||
BOOST_TEST( x.state() == n );
|
||||
}
|
||||
|
||||
void stateful_function_test()
|
||||
{
|
||||
test( boost::bind( f0, 0 ), 0, 17041 );
|
||||
test( boost::bind( f1, 0, 1 ), 0, 1 );
|
||||
test( boost::bind( f2, 0, 1, 2 ), 0, 1+2 );
|
||||
test( boost::bind( f3, 0, 1, 2, 3 ), 0, 1+2+3 );
|
||||
test( boost::bind( f4, 0, 1, 2, 3, 4 ), 0, 1+2+3+4 );
|
||||
test( boost::bind( f5, 0, 1, 2, 3, 4, 5 ), 0, 1+2+3+4+5 );
|
||||
test( boost::bind( f6, 0, 1, 2, 3, 4, 5, 6 ), 0, 1+2+3+4+5+6 );
|
||||
test( boost::bind( f7, 0, 1, 2, 3, 4, 5, 6, 7 ), 0, 1+2+3+4+5+6+7 );
|
||||
test( boost::bind( f8, 0, 1, 2, 3, 4, 5, 6, 7, 8 ), 0, 1+2+3+4+5+6+7+8 );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
stateful_function_object_test();
|
||||
stateful_function_test();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -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
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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_STDCALL
|
||||
|
||||
@@ -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
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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_STDCALL
|
||||
|
||||
@@ -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
|
||||
@@ -13,9 +11,10 @@
|
||||
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2001 David Abrahams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
@@ -189,7 +188,7 @@ void function_object_test()
|
||||
BOOST_TEST( bind<int>(Y(), i, _1)(k) == 38 );
|
||||
BOOST_TEST( bind<long>(Y(), i, _1, 9)(k) == 938 );
|
||||
|
||||
#if !defined(__MWERKS__) || (__MWERKS__ > 0x2407) // Fails for this version of the compiler.
|
||||
#if !defined(__MWERKS__) || (__MWERKS__ > 0x2406) // Fails for this version of the compiler.
|
||||
|
||||
global_result = 0;
|
||||
bind<void>(Y(), i, _1, 9, 4)(k);
|
||||
|
||||
@@ -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
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
|
||||
#include <boost/mem_fn.hpp>
|
||||
|
||||
@@ -1,300 +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_eq_test.cpp - boost::mem_fn equality operator
|
||||
//
|
||||
// Copyright (c) 2004 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/mem_fn.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
|
||||
{
|
||||
int dm_1;
|
||||
int dm_2;
|
||||
|
||||
// 0
|
||||
|
||||
int mf0_1() { return 0; }
|
||||
int mf0_2() { return 0; }
|
||||
|
||||
int cmf0_1() const { return 0; }
|
||||
int cmf0_2() const { return 0; }
|
||||
|
||||
void mf0v_1() {}
|
||||
void mf0v_2() {}
|
||||
|
||||
void cmf0v_1() const {}
|
||||
void cmf0v_2() const {}
|
||||
|
||||
// 1
|
||||
|
||||
int mf1_1(int) { return 0; }
|
||||
int mf1_2(int) { return 0; }
|
||||
|
||||
int cmf1_1(int) const { return 0; }
|
||||
int cmf1_2(int) const { return 0; }
|
||||
|
||||
void mf1v_1(int) {}
|
||||
void mf1v_2(int) {}
|
||||
|
||||
void cmf1v_1(int) const {}
|
||||
void cmf1v_2(int) const {}
|
||||
|
||||
// 2
|
||||
|
||||
int mf2_1(int, int) { return 0; }
|
||||
int mf2_2(int, int) { return 0; }
|
||||
|
||||
int cmf2_1(int, int) const { return 0; }
|
||||
int cmf2_2(int, int) const { return 0; }
|
||||
|
||||
void mf2v_1(int, int) {}
|
||||
void mf2v_2(int, int) {}
|
||||
|
||||
void cmf2v_1(int, int) const {}
|
||||
void cmf2v_2(int, int) const {}
|
||||
|
||||
// 3
|
||||
|
||||
int mf3_1(int, int, int) { return 0; }
|
||||
int mf3_2(int, int, int) { return 0; }
|
||||
|
||||
int cmf3_1(int, int, int) const { return 0; }
|
||||
int cmf3_2(int, int, int) const { return 0; }
|
||||
|
||||
void mf3v_1(int, int, int) {}
|
||||
void mf3v_2(int, int, int) {}
|
||||
|
||||
void cmf3v_1(int, int, int) const {}
|
||||
void cmf3v_2(int, int, int) const {}
|
||||
|
||||
// 4
|
||||
|
||||
int mf4_1(int, int, int, int) { return 0; }
|
||||
int mf4_2(int, int, int, int) { return 0; }
|
||||
|
||||
int cmf4_1(int, int, int, int) const { return 0; }
|
||||
int cmf4_2(int, int, int, int) const { return 0; }
|
||||
|
||||
void mf4v_1(int, int, int, int) {}
|
||||
void mf4v_2(int, int, int, int) {}
|
||||
|
||||
void cmf4v_1(int, int, int, int) const {}
|
||||
void cmf4v_2(int, int, int, int) const {}
|
||||
|
||||
// 5
|
||||
|
||||
int mf5_1(int, int, int, int, int) { return 0; }
|
||||
int mf5_2(int, int, int, int, int) { return 0; }
|
||||
|
||||
int cmf5_1(int, int, int, int, int) const { return 0; }
|
||||
int cmf5_2(int, int, int, int, int) const { return 0; }
|
||||
|
||||
void mf5v_1(int, int, int, int, int) {}
|
||||
void mf5v_2(int, int, int, int, int) {}
|
||||
|
||||
void cmf5v_1(int, int, int, int, int) const {}
|
||||
void cmf5v_2(int, int, int, int, int) const {}
|
||||
|
||||
// 6
|
||||
|
||||
int mf6_1(int, int, int, int, int, int) { return 0; }
|
||||
int mf6_2(int, int, int, int, int, int) { return 0; }
|
||||
|
||||
int cmf6_1(int, int, int, int, int, int) const { return 0; }
|
||||
int cmf6_2(int, int, int, int, int, int) const { return 0; }
|
||||
|
||||
void mf6v_1(int, int, int, int, int, int) {}
|
||||
void mf6v_2(int, int, int, int, int, int) {}
|
||||
|
||||
void cmf6v_1(int, int, int, int, int, int) const {}
|
||||
void cmf6v_2(int, int, int, int, int, int) const {}
|
||||
|
||||
// 7
|
||||
|
||||
int mf7_1(int, int, int, int, int, int, int) { return 0; }
|
||||
int mf7_2(int, int, int, int, int, int, int) { return 0; }
|
||||
|
||||
int cmf7_1(int, int, int, int, int, int, int) const { return 0; }
|
||||
int cmf7_2(int, int, int, int, int, int, int) const { return 0; }
|
||||
|
||||
void mf7v_1(int, int, int, int, int, int, int) {}
|
||||
void mf7v_2(int, int, int, int, int, int, int) {}
|
||||
|
||||
void cmf7v_1(int, int, int, int, int, int, int) const {}
|
||||
void cmf7v_2(int, int, int, int, int, int, int) const {}
|
||||
|
||||
// 8
|
||||
|
||||
int mf8_1(int, int, int, int, int, int, int, int) { return 0; }
|
||||
int mf8_2(int, int, int, int, int, int, int, int) { return 0; }
|
||||
|
||||
int cmf8_1(int, int, int, int, int, int, int, int) const { return 0; }
|
||||
int cmf8_2(int, int, int, int, int, int, int, int) const { return 0; }
|
||||
|
||||
void mf8v_1(int, int, int, int, int, int, int, int) {}
|
||||
void mf8v_2(int, int, int, int, int, int, int, int) {}
|
||||
|
||||
void cmf8v_1(int, int, int, int, int, int, int, int) const {}
|
||||
void cmf8v_2(int, int, int, int, int, int, int, int) const {}
|
||||
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
BOOST_TEST( boost::mem_fn(&X::dm_1) == boost::mem_fn(&X::dm_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::dm_1) != boost::mem_fn(&X::dm_2) );
|
||||
|
||||
// 0
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf0_1) == boost::mem_fn(&X::mf0_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf0_1) != boost::mem_fn(&X::mf0_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf0_1) == boost::mem_fn(&X::cmf0_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf0_1) != boost::mem_fn(&X::cmf0_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf0v_1) == boost::mem_fn(&X::mf0v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf0v_1) != boost::mem_fn(&X::mf0v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf0v_1) == boost::mem_fn(&X::cmf0v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf0v_1) != boost::mem_fn(&X::cmf0v_2) );
|
||||
|
||||
// 1
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf1_1) == boost::mem_fn(&X::mf1_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf1_1) != boost::mem_fn(&X::mf1_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf1_1) == boost::mem_fn(&X::cmf1_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf1_1) != boost::mem_fn(&X::cmf1_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf1v_1) == boost::mem_fn(&X::mf1v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf1v_1) != boost::mem_fn(&X::mf1v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf1v_1) == boost::mem_fn(&X::cmf1v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf1v_1) != boost::mem_fn(&X::cmf1v_2) );
|
||||
|
||||
// 2
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf2_1) == boost::mem_fn(&X::mf2_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf2_1) != boost::mem_fn(&X::mf2_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf2_1) == boost::mem_fn(&X::cmf2_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf2_1) != boost::mem_fn(&X::cmf2_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf2v_1) == boost::mem_fn(&X::mf2v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf2v_1) != boost::mem_fn(&X::mf2v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf2v_1) == boost::mem_fn(&X::cmf2v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf2v_1) != boost::mem_fn(&X::cmf2v_2) );
|
||||
|
||||
// 3
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf3_1) == boost::mem_fn(&X::mf3_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf3_1) != boost::mem_fn(&X::mf3_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf3_1) == boost::mem_fn(&X::cmf3_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf3_1) != boost::mem_fn(&X::cmf3_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf3v_1) == boost::mem_fn(&X::mf3v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf3v_1) != boost::mem_fn(&X::mf3v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf3v_1) == boost::mem_fn(&X::cmf3v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf3v_1) != boost::mem_fn(&X::cmf3v_2) );
|
||||
|
||||
// 4
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf4_1) == boost::mem_fn(&X::mf4_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf4_1) != boost::mem_fn(&X::mf4_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf4_1) == boost::mem_fn(&X::cmf4_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf4_1) != boost::mem_fn(&X::cmf4_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf4v_1) == boost::mem_fn(&X::mf4v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf4v_1) != boost::mem_fn(&X::mf4v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf4v_1) == boost::mem_fn(&X::cmf4v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf4v_1) != boost::mem_fn(&X::cmf4v_2) );
|
||||
|
||||
// 5
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf5_1) == boost::mem_fn(&X::mf5_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf5_1) != boost::mem_fn(&X::mf5_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf5_1) == boost::mem_fn(&X::cmf5_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf5_1) != boost::mem_fn(&X::cmf5_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf5v_1) == boost::mem_fn(&X::mf5v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf5v_1) != boost::mem_fn(&X::mf5v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf5v_1) == boost::mem_fn(&X::cmf5v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf5v_1) != boost::mem_fn(&X::cmf5v_2) );
|
||||
|
||||
// 6
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf6_1) == boost::mem_fn(&X::mf6_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf6_1) != boost::mem_fn(&X::mf6_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf6_1) == boost::mem_fn(&X::cmf6_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf6_1) != boost::mem_fn(&X::cmf6_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf6v_1) == boost::mem_fn(&X::mf6v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf6v_1) != boost::mem_fn(&X::mf6v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf6v_1) == boost::mem_fn(&X::cmf6v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf6v_1) != boost::mem_fn(&X::cmf6v_2) );
|
||||
|
||||
// 7
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf7_1) == boost::mem_fn(&X::mf7_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf7_1) != boost::mem_fn(&X::mf7_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf7_1) == boost::mem_fn(&X::cmf7_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf7_1) != boost::mem_fn(&X::cmf7_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf7v_1) == boost::mem_fn(&X::mf7v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf7v_1) != boost::mem_fn(&X::mf7v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf7v_1) == boost::mem_fn(&X::cmf7v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf7v_1) != boost::mem_fn(&X::cmf7v_2) );
|
||||
|
||||
// 8
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf8_1) == boost::mem_fn(&X::mf8_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf8_1) != boost::mem_fn(&X::mf8_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf8_1) == boost::mem_fn(&X::cmf8_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf8_1) != boost::mem_fn(&X::cmf8_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf8v_1) == boost::mem_fn(&X::mf8v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf8v_1) != boost::mem_fn(&X::mf8v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf8v_1) == boost::mem_fn(&X::cmf8v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf8v_1) != boost::mem_fn(&X::cmf8v_2) );
|
||||
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -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
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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
|
||||
|
||||
@@ -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
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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_STDCALL
|
||||
|
||||
@@ -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
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
|
||||
#include <boost/mem_fn.hpp>
|
||||
|
||||
@@ -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
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// 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.
|
||||
//
|
||||
|
||||
#include <boost/mem_fn.hpp>
|
||||
|
||||
Reference in New Issue
Block a user