mirror of
https://github.com/boostorg/function.git
synced 2026-01-29 07:32:15 +00:00
Compare commits
26 Commits
svn-branch
...
boost-1.46
| Author | SHA1 | Date | |
|---|---|---|---|
|
bd84f2a232 | ||
|
f85a3db133 | ||
|
a0286a58c7 | ||
|
1b6a5673cb | ||
|
24a7ce00a8 | ||
|
|
c398dfceb3 | ||
|
|
a108a1cf26 | ||
|
|
d68cc8a51c | ||
|
|
cca7b35712 | ||
|
9bb12ce87a | ||
|
467ae9613f | ||
|
|
2fd383cd2e | ||
|
587658b047 | ||
|
|
83309a36c7 | ||
|
|
bfdb5b161d | ||
|
|
c4539395fe | ||
|
|
6147e7ddcc | ||
|
1b60e82b2f | ||
|
7581949360 | ||
|
|
0b2aeda226 | ||
|
2ecd62c612 | ||
|
|
47033bd162 | ||
|
|
c7d5016022 | ||
|
|
d92355cca2 | ||
|
|
0123f84bff | ||
|
|
0207da8008 |
@@ -13,15 +13,6 @@
|
||||
|
||||
<itemizedlist spacing="compact">
|
||||
|
||||
<listitem><para><bold>Version 1.52.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Move constructors and move assignment
|
||||
operators added (only for compilers with C++11 rvalue
|
||||
references support). Original patch
|
||||
contributed by Antony Polukhin.</para></listitem>
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.37.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Improved the performance of Boost.Function's
|
||||
|
||||
@@ -58,7 +58,7 @@
|
||||
<para>A function object <code>f</code> of
|
||||
type <code>F</code> is
|
||||
<emphasis>stateless</emphasis> if it is a function pointer or if
|
||||
<code><classname>boost::is_stateless</classname><F></code>
|
||||
<code><classname>boost::is_stateless</classname><T></code>
|
||||
is true. The construction of or copy to a Boost.Function object
|
||||
from a stateless function object will not cause exceptions to be
|
||||
thrown and will not allocate any storage.
|
||||
@@ -203,15 +203,6 @@
|
||||
<throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<parameter name="f">
|
||||
<paramtype><classname>functionN</classname>&&</paramtype>
|
||||
</parameter>
|
||||
<requires><simpara>C++11 compatible compiler.</simpara></requires>
|
||||
<postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
@@ -245,15 +236,6 @@
|
||||
</parameter>
|
||||
<postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-><methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
</copy-assignment>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype><classname>functionN</classname>&&</paramtype>
|
||||
</parameter>
|
||||
<requires><simpara>C++11 compatible compiler.</simpara></requires>
|
||||
<postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<method-group name="modifiers">
|
||||
<method name="swap">
|
||||
@@ -625,16 +607,7 @@
|
||||
<postconditions><simpara>Contains a copy of the <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<parameter name="f">
|
||||
<paramtype><classname>functionN</classname>&&</paramtype>
|
||||
</parameter>
|
||||
<requires><simpara>C++11 compatible compiler.</simpara></requires>
|
||||
<postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
|
||||
<constructor>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>function</classname>&</paramtype>
|
||||
@@ -643,15 +616,6 @@
|
||||
<throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<parameter name="f">
|
||||
<paramtype><classname>function</classname>&&</paramtype>
|
||||
</parameter>
|
||||
<requires><simpara>C++11 compatible compiler.</simpara></requires>
|
||||
<postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
@@ -681,19 +645,10 @@
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>functionN</classname>&</paramtype>
|
||||
<paramtype>const <classname>function</classname>&</paramtype>
|
||||
</parameter>
|
||||
<postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-><methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
</copy-assignment>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype><classname>functionN</classname>&&</paramtype>
|
||||
</parameter>
|
||||
<requires><simpara>C++11 compatible compiler.</simpara></requires>
|
||||
<postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
@@ -702,15 +657,6 @@
|
||||
<postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
|
||||
<throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-><methodname>empty</methodname>()</code>.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype><classname>function</classname>&&</paramtype>
|
||||
</parameter>
|
||||
<requires><simpara>C++11 compatible compiler.</simpara></requires>
|
||||
<postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<method-group name="modifiers">
|
||||
<method name="swap">
|
||||
|
||||
@@ -23,8 +23,8 @@
|
||||
// in anything that may be included by function_template.hpp doesn't break
|
||||
#include <boost/function/detail/prologue.hpp>
|
||||
|
||||
// Older Visual Age C++ version do not handle the file iteration well
|
||||
#if BOOST_WORKAROUND(__IBMCPP__, >= 500) && BOOST_WORKAROUND(__IBMCPP__, < 800)
|
||||
// Visual Age C++ doesn't handle the file iteration well
|
||||
#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 0
|
||||
# include <boost/function/function0.hpp>
|
||||
# endif
|
||||
|
||||
@@ -203,11 +203,11 @@ namespace boost {
|
||||
{
|
||||
switch (op) {
|
||||
case clone_functor_tag:
|
||||
out_buffer.obj_ref = in_buffer.obj_ref;
|
||||
out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
|
||||
return;
|
||||
|
||||
case move_functor_tag:
|
||||
out_buffer.obj_ref = in_buffer.obj_ref;
|
||||
out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
|
||||
in_buffer.obj_ref.obj_ptr = 0;
|
||||
return;
|
||||
|
||||
@@ -315,18 +315,14 @@ namespace boost {
|
||||
if (op == clone_functor_tag || op == move_functor_tag) {
|
||||
const functor_type* in_functor =
|
||||
reinterpret_cast<const functor_type*>(&in_buffer.data);
|
||||
new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);
|
||||
new ((void*)&out_buffer.data) functor_type(*in_functor);
|
||||
|
||||
if (op == move_functor_tag) {
|
||||
functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
|
||||
(void)f; // suppress warning about the value of f not being used (MSVC)
|
||||
f->~Functor();
|
||||
reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor();
|
||||
}
|
||||
} else if (op == destroy_functor_tag) {
|
||||
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
|
||||
functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
|
||||
(void)f; // suppress warning about the value of f not being used (MSVC)
|
||||
f->~Functor();
|
||||
reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
|
||||
} else if (op == check_functor_type_tag) {
|
||||
const detail::sp_typeinfo& check_type
|
||||
= *out_buffer.type.type;
|
||||
@@ -373,10 +369,8 @@ namespace boost {
|
||||
// Clone the functor
|
||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||
// can't do the static_cast that we should do.
|
||||
// jewillco: Changing this to static_cast because GCC 2.95.3 is
|
||||
// obsolete.
|
||||
const functor_type* f =
|
||||
static_cast<const functor_type*>(in_buffer.obj_ptr);
|
||||
(const functor_type*)(in_buffer.obj_ptr);
|
||||
functor_type* new_f = new functor_type(*f);
|
||||
out_buffer.obj_ptr = new_f;
|
||||
} else if (op == move_functor_tag) {
|
||||
@@ -480,7 +474,7 @@ namespace boost {
|
||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||
// can't do the static_cast that we should do.
|
||||
const functor_wrapper_type* f =
|
||||
static_cast<const functor_wrapper_type*>(in_buffer.obj_ptr);
|
||||
(const functor_wrapper_type*)(in_buffer.obj_ptr);
|
||||
wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
|
||||
wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
|
||||
wrapper_allocator.construct(copy, *f);
|
||||
@@ -677,7 +671,7 @@ public:
|
||||
detail::function::check_functor_type_tag);
|
||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||
// can't do the static_cast that we should do.
|
||||
return static_cast<const Functor*>(type_result.obj_ptr);
|
||||
return (const Functor*)(type_result.obj_ptr);
|
||||
}
|
||||
|
||||
template<typename F>
|
||||
@@ -721,7 +715,7 @@ public:
|
||||
public: // should be protected, but GCC 2.95.3 will fail to allow access
|
||||
detail::function::vtable_base* get_vtable() const {
|
||||
return reinterpret_cast<detail::function::vtable_base*>(
|
||||
reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
|
||||
reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
|
||||
}
|
||||
|
||||
bool has_trivial_copy_and_destroy() const {
|
||||
|
||||
@@ -486,19 +486,19 @@ namespace boost {
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS);
|
||||
|
||||
template<typename F>
|
||||
bool assign_to(F f, function_buffer& functor) const
|
||||
bool assign_to(F f, function_buffer& functor)
|
||||
{
|
||||
typedef typename get_function_tag<F>::type tag;
|
||||
return assign_to(f, functor, tag());
|
||||
}
|
||||
template<typename F,typename Allocator>
|
||||
bool assign_to_a(F f, function_buffer& functor, Allocator a) const
|
||||
bool assign_to_a(F f, function_buffer& functor, Allocator a)
|
||||
{
|
||||
typedef typename get_function_tag<F>::type tag;
|
||||
return assign_to_a(f, functor, a, tag());
|
||||
}
|
||||
|
||||
void clear(function_buffer& functor) const
|
||||
void clear(function_buffer& functor)
|
||||
{
|
||||
if (base.manager)
|
||||
base.manager(functor, functor, destroy_functor_tag);
|
||||
@@ -508,13 +508,13 @@ namespace boost {
|
||||
// Function pointers
|
||||
template<typename FunctionPtr>
|
||||
bool
|
||||
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
|
||||
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
|
||||
{
|
||||
this->clear(functor);
|
||||
if (f) {
|
||||
// should be a reinterpret cast, but some compilers insist
|
||||
// on giving cv-qualifiers to free functions
|
||||
functor.func_ptr = reinterpret_cast<void (*)()>(f);
|
||||
functor.func_ptr = (void (*)())(f);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
@@ -522,7 +522,7 @@ namespace boost {
|
||||
}
|
||||
template<typename FunctionPtr,typename Allocator>
|
||||
bool
|
||||
assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
|
||||
assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
|
||||
{
|
||||
return assign_to(f,functor,function_ptr_tag());
|
||||
}
|
||||
@@ -530,26 +530,26 @@ namespace boost {
|
||||
// Member pointers
|
||||
#if BOOST_FUNCTION_NUM_ARGS > 0
|
||||
template<typename MemberPtr>
|
||||
bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
|
||||
bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
|
||||
{
|
||||
// DPG TBD: Add explicit support for member function
|
||||
// objects, so we invoke through mem_fn() but we retain the
|
||||
// right target_type() values.
|
||||
if (f) {
|
||||
this->assign_to(boost::mem_fn(f), functor);
|
||||
this->assign_to(mem_fn(f), functor);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
template<typename MemberPtr,typename Allocator>
|
||||
bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
|
||||
bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
|
||||
{
|
||||
// DPG TBD: Add explicit support for member function
|
||||
// objects, so we invoke through mem_fn() but we retain the
|
||||
// right target_type() values.
|
||||
if (f) {
|
||||
this->assign_to_a(boost::mem_fn(f), functor, a);
|
||||
this->assign_to_a(mem_fn(f), functor, a);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
@@ -561,13 +561,13 @@ namespace boost {
|
||||
// Assign to a function object using the small object optimization
|
||||
template<typename FunctionObj>
|
||||
void
|
||||
assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
|
||||
assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
|
||||
{
|
||||
new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
|
||||
new ((void*)&functor.data) FunctionObj(f);
|
||||
}
|
||||
template<typename FunctionObj,typename Allocator>
|
||||
void
|
||||
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
|
||||
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
|
||||
{
|
||||
assign_functor(f,functor,mpl::true_());
|
||||
}
|
||||
@@ -575,13 +575,13 @@ namespace boost {
|
||||
// Assign to a function object allocated on the heap.
|
||||
template<typename FunctionObj>
|
||||
void
|
||||
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
|
||||
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
|
||||
{
|
||||
functor.obj_ptr = new FunctionObj(f);
|
||||
}
|
||||
template<typename FunctionObj,typename Allocator>
|
||||
void
|
||||
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
|
||||
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
|
||||
{
|
||||
typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
|
||||
typedef typename Allocator::template rebind<functor_wrapper_type>::other
|
||||
@@ -596,7 +596,7 @@ namespace boost {
|
||||
|
||||
template<typename FunctionObj>
|
||||
bool
|
||||
assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
|
||||
assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
|
||||
{
|
||||
if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
|
||||
assign_functor(f, functor,
|
||||
@@ -608,7 +608,7 @@ namespace boost {
|
||||
}
|
||||
template<typename FunctionObj,typename Allocator>
|
||||
bool
|
||||
assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
|
||||
assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
|
||||
{
|
||||
if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
|
||||
assign_functor_a(f, functor, a,
|
||||
@@ -623,9 +623,9 @@ namespace boost {
|
||||
template<typename FunctionObj>
|
||||
bool
|
||||
assign_to(const reference_wrapper<FunctionObj>& f,
|
||||
function_buffer& functor, function_obj_ref_tag) const
|
||||
function_buffer& functor, function_obj_ref_tag)
|
||||
{
|
||||
functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
|
||||
functor.obj_ref.obj_ptr = (void *)f.get_pointer();
|
||||
functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
|
||||
functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
|
||||
return true;
|
||||
@@ -633,7 +633,7 @@ namespace boost {
|
||||
template<typename FunctionObj,typename Allocator>
|
||||
bool
|
||||
assign_to_a(const reference_wrapper<FunctionObj>& f,
|
||||
function_buffer& functor, Allocator, function_obj_ref_tag) const
|
||||
function_buffer& functor, Allocator, function_obj_ref_tag)
|
||||
{
|
||||
return assign_to(f,functor,function_obj_ref_tag());
|
||||
}
|
||||
@@ -677,7 +677,7 @@ namespace boost {
|
||||
|
||||
vtable_type* get_vtable() const {
|
||||
return reinterpret_cast<vtable_type*>(
|
||||
reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
|
||||
reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
|
||||
}
|
||||
|
||||
struct clear_type {};
|
||||
@@ -748,16 +748,12 @@ namespace boost {
|
||||
{
|
||||
this->assign_to_own(f);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
BOOST_FUNCTION_FUNCTION(BOOST_FUNCTION_FUNCTION&& f) : function_base()
|
||||
{
|
||||
this->move_assign(f);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
~BOOST_FUNCTION_FUNCTION() { clear(); }
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
// MSVC 6.0 and prior require all definitions to be inline, but
|
||||
// these definitions can become very costly.
|
||||
result_type operator()(BOOST_FUNCTION_PARMS) const
|
||||
{
|
||||
if (this->empty())
|
||||
@@ -766,6 +762,9 @@ namespace boost {
|
||||
return get_vtable()->invoker
|
||||
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
#else
|
||||
result_type operator()(BOOST_FUNCTION_PARMS) const;
|
||||
#endif
|
||||
|
||||
// The distinction between when to use BOOST_FUNCTION_FUNCTION and
|
||||
// when to use self_type is obnoxious. MSVC cannot handle self_type as
|
||||
@@ -837,26 +836,6 @@ namespace boost {
|
||||
BOOST_CATCH_END
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
// Move assignment from another BOOST_FUNCTION_FUNCTION
|
||||
BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f)
|
||||
{
|
||||
|
||||
if (&f == this)
|
||||
return *this;
|
||||
|
||||
this->clear();
|
||||
BOOST_TRY {
|
||||
this->move_assign(f);
|
||||
} BOOST_CATCH (...) {
|
||||
vtable = 0;
|
||||
BOOST_RETHROW;
|
||||
}
|
||||
BOOST_CATCH_END
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
|
||||
void swap(BOOST_FUNCTION_FUNCTION& other)
|
||||
{
|
||||
@@ -885,7 +864,7 @@ namespace boost {
|
||||
#else
|
||||
private:
|
||||
struct dummy {
|
||||
void nonnull() {}
|
||||
void nonnull() {};
|
||||
};
|
||||
|
||||
typedef void (dummy::*safe_bool)();
|
||||
@@ -930,7 +909,7 @@ namespace boost {
|
||||
// static initialization. Otherwise, we will have a race
|
||||
// condition here in multi-threaded code. See
|
||||
// http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
|
||||
static const vtable_type stored_vtable =
|
||||
static vtable_type stored_vtable =
|
||||
{ { &manager_type::manage }, &invoker_type::invoke };
|
||||
|
||||
if (stored_vtable.assign_to(f, functor)) {
|
||||
@@ -938,7 +917,7 @@ namespace boost {
|
||||
if (boost::has_trivial_copy_constructor<Functor>::value &&
|
||||
boost::has_trivial_destructor<Functor>::value &&
|
||||
detail::function::function_allows_small_object_optimization<Functor>::value)
|
||||
value |= static_cast<size_t>(0x01);
|
||||
value |= (std::size_t)0x01;
|
||||
vtable = reinterpret_cast<detail::function::vtable_base *>(value);
|
||||
} else
|
||||
vtable = 0;
|
||||
@@ -964,7 +943,7 @@ namespace boost {
|
||||
// static initialization. Otherwise, we will have a race
|
||||
// condition here in multi-threaded code. See
|
||||
// http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
|
||||
static const vtable_type stored_vtable =
|
||||
static vtable_type stored_vtable =
|
||||
{ { &manager_type::manage }, &invoker_type::invoke };
|
||||
|
||||
if (stored_vtable.assign_to_a(f, functor, a)) {
|
||||
@@ -972,7 +951,7 @@ namespace boost {
|
||||
if (boost::has_trivial_copy_constructor<Functor>::value &&
|
||||
boost::has_trivial_destructor<Functor>::value &&
|
||||
detail::function::function_allows_small_object_optimization<Functor>::value)
|
||||
value |= static_cast<std::size_t>(0x01);
|
||||
value |= (std::size_t)0x01;
|
||||
vtable = reinterpret_cast<detail::function::vtable_base *>(value);
|
||||
} else
|
||||
vtable = 0;
|
||||
@@ -1019,6 +998,22 @@ namespace boost {
|
||||
f1.swap(f2);
|
||||
}
|
||||
|
||||
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||
typename BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>::result_type
|
||||
inline
|
||||
BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
|
||||
::operator()(BOOST_FUNCTION_PARMS) const
|
||||
{
|
||||
if (this->empty())
|
||||
boost::throw_exception(bad_function_call());
|
||||
|
||||
return get_vtable()->invoker
|
||||
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Poison comparisons between boost::function objects of the same type.
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||
void operator==(const BOOST_FUNCTION_FUNCTION<
|
||||
@@ -1090,26 +1085,12 @@ public:
|
||||
|
||||
function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
// Move constructors
|
||||
function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
|
||||
function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
|
||||
#endif
|
||||
|
||||
self_type& operator=(const self_type& f)
|
||||
{
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
self_type& operator=(self_type&& f)
|
||||
{
|
||||
self_type(static_cast<self_type&&>(f)).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
|
||||
template<typename Functor>
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
typename enable_if_c<
|
||||
@@ -1138,14 +1119,6 @@ public:
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
self_type& operator=(base_type&& f)
|
||||
{
|
||||
self_type(static_cast<base_type&&>(f)).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
#undef BOOST_FUNCTION_PARTIAL_SPEC
|
||||
|
||||
@@ -8,7 +8,6 @@
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
project
|
||||
: requirements <toolset>msvc:<asynch-exceptions>on
|
||||
: source-location $(BOOST_ROOT)
|
||||
;
|
||||
|
||||
|
||||
@@ -690,95 +690,6 @@ static void test_call()
|
||||
test_call_cref(std::plus<int>());
|
||||
}
|
||||
|
||||
struct big_aggregating_structure {
|
||||
int disable_small_objects_optimizations[32];
|
||||
|
||||
big_aggregating_structure()
|
||||
{
|
||||
++ global_int;
|
||||
}
|
||||
|
||||
big_aggregating_structure(const big_aggregating_structure&)
|
||||
{
|
||||
++ global_int;
|
||||
}
|
||||
|
||||
~big_aggregating_structure()
|
||||
{
|
||||
-- global_int;
|
||||
}
|
||||
|
||||
void operator()()
|
||||
{
|
||||
++ global_int;
|
||||
}
|
||||
|
||||
void operator()(int)
|
||||
{
|
||||
++ global_int;
|
||||
}
|
||||
};
|
||||
|
||||
template <class FunctionT>
|
||||
static void test_move_semantics()
|
||||
{
|
||||
typedef FunctionT f1_type;
|
||||
|
||||
big_aggregating_structure obj;
|
||||
|
||||
f1_type f1 = obj;
|
||||
global_int = 0;
|
||||
f1();
|
||||
|
||||
BOOST_CHECK(!f1.empty());
|
||||
BOOST_CHECK(global_int == 1);
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
// Testing rvalue constructors
|
||||
f1_type f2(static_cast<f1_type&&>(f1));
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_CHECK(!f2.empty());
|
||||
BOOST_CHECK(global_int == 1);
|
||||
f2();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
|
||||
f1_type f3(static_cast<f1_type&&>(f2));
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_CHECK(f2.empty());
|
||||
BOOST_CHECK(!f3.empty());
|
||||
BOOST_CHECK(global_int == 2);
|
||||
f3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Testing move assignment
|
||||
f1_type f4;
|
||||
BOOST_CHECK(f4.empty());
|
||||
f4 = static_cast<f1_type&&>(f3);
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_CHECK(f2.empty());
|
||||
BOOST_CHECK(f3.empty());
|
||||
BOOST_CHECK(!f4.empty());
|
||||
BOOST_CHECK(global_int == 3);
|
||||
f4();
|
||||
BOOST_CHECK(global_int == 4);
|
||||
|
||||
// Testing self move assignment
|
||||
f4 = static_cast<f1_type&&>(f4);
|
||||
BOOST_CHECK(!f4.empty());
|
||||
BOOST_CHECK(global_int == 4);
|
||||
|
||||
// Testing, that no memory leaked when assigning to nonempty function
|
||||
f4 = obj;
|
||||
BOOST_CHECK(!f4.empty());
|
||||
BOOST_CHECK(global_int == 4);
|
||||
f1_type f5 = obj;
|
||||
BOOST_CHECK(global_int == 5);
|
||||
f4 = static_cast<f1_type&&>(f5);
|
||||
BOOST_CHECK(global_int == 4);
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
int test_main(int, char* [])
|
||||
{
|
||||
test_zero_args();
|
||||
@@ -791,8 +702,6 @@ int test_main(int, char* [])
|
||||
test_exception();
|
||||
test_implicit();
|
||||
test_call();
|
||||
test_move_semantics<function<void()> >();
|
||||
test_move_semantics<boost::function0<void> >();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -10,28 +10,22 @@
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
|
||||
struct X {
|
||||
int foo(int);
|
||||
std::ostream& foo2(std::ostream&) const;
|
||||
};
|
||||
int X::foo(int x) { return -x; }
|
||||
std::ostream& X::foo2(std::ostream& x) const { return x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function<int (X*, int)> f;
|
||||
boost::function<std::ostream& (X*, std::ostream&)> f2;
|
||||
|
||||
f = &X::foo;
|
||||
f2 = &X::foo2;
|
||||
f = &X::foo;
|
||||
|
||||
X x;
|
||||
f(&x, 5);
|
||||
|
||||
X x;
|
||||
BOOST_TEST(f(&x, 5) == -5);
|
||||
BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout);
|
||||
|
||||
return ::boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -10,28 +10,22 @@
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
|
||||
struct X {
|
||||
int foo(int);
|
||||
std::ostream& foo2(std::ostream&) const;
|
||||
};
|
||||
int X::foo(int x) { return -x; }
|
||||
std::ostream& X::foo2(std::ostream& x) const { return x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function2<int, X*, int> f;
|
||||
boost::function2<std::ostream&, X*, std::ostream&> f2;
|
||||
|
||||
f = &X::foo;
|
||||
f2 = &X::foo2;
|
||||
f = &X::foo;
|
||||
|
||||
X x;
|
||||
f(&x, 5);
|
||||
|
||||
X x;
|
||||
BOOST_TEST(f(&x, 5) == -5);
|
||||
BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout);
|
||||
|
||||
return ::boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user