boostorg/function
1
0
Fork 1
mirror of https://github.com/boostorg/function.git synced 2025-07-31 13:27:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #9 from Lastique/fix_placement_new_warnings

Browse Source 
Fix gcc 6 warnings about invoking placement new on a buffer of insufficient size.  Tested with gcc-6.1.0 on RHEL, seems okay.
This commit is contained in:
Noel Belcourt
2016-07-11 16:24:49 -06:00
committed by GitHub
parent 3eb8954877 54988e8e91
commit fed32bc072
2 changed files with 169 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -65,10 +65,11 @@ namespace boost {
* object pointers, and a structure that resembles a bound * object pointers, and a structure that resembles a bound
* member function pointer. * member function pointer.
*/ */
union function_buffer union function_buffer_members
{ {
// For pointers to function objects // For pointers to function objects
mutable void* obj_ptr; typedef void* obj_ptr_t;
mutable obj_ptr_t obj_ptr;
// For pointers to std::type_info objects // For pointers to std::type_info objects
struct type_t { struct type_t {
@ -82,7 +83,8 @@ namespace boost {
} type; } type;
// For function pointers of all kinds // For function pointers of all kinds
mutable void (*func_ptr)(); typedef void (*func_ptr_t)();
mutable func_ptr_t func_ptr;
// For bound member pointers // For bound member pointers
struct bound_memfunc_ptr_t { struct bound_memfunc_ptr_t {
@ -97,9 +99,15 @@ namespace boost {
bool is_const_qualified; bool is_const_qualified;
bool is_volatile_qualified; bool is_volatile_qualified;
} obj_ref; } obj_ref;
};
union function_buffer
{
// Type-specific union members
mutable function_buffer_members members;
// To relax aliasing constraints // To relax aliasing constraints
mutable char data; mutable char data[sizeof(function_buffer_members)];
}; };
/** /**
@ -171,37 +179,37 @@ namespace boost {
{ {
switch (op) { switch (op) {
case clone_functor_tag: case clone_functor_tag:
out_buffer.obj_ref = in_buffer.obj_ref; out_buffer.members.obj_ref = in_buffer.members.obj_ref;
return; return;
case move_functor_tag: case move_functor_tag:
out_buffer.obj_ref = in_buffer.obj_ref; out_buffer.members.obj_ref = in_buffer.members.obj_ref;
in_buffer.obj_ref.obj_ptr = 0; in_buffer.members.obj_ref.obj_ptr = 0;
return; return;
case destroy_functor_tag: case destroy_functor_tag:
out_buffer.obj_ref.obj_ptr = 0; out_buffer.members.obj_ref.obj_ptr = 0;
return; return;
case check_functor_type_tag: case check_functor_type_tag:
{ {
// Check whether we have the same type. We can add // Check whether we have the same type. We can add
// cv-qualifiers, but we can't take them away. // cv-qualifiers, but we can't take them away.
if (*out_buffer.type.type == boost::typeindex::type_id<F>() if (*out_buffer.members.type.type == boost::typeindex::type_id<F>()
&& (!in_buffer.obj_ref.is_const_qualified && (!in_buffer.members.obj_ref.is_const_qualified
|| out_buffer.type.const_qualified) || out_buffer.members.type.const_qualified)
&& (!in_buffer.obj_ref.is_volatile_qualified && (!in_buffer.members.obj_ref.is_volatile_qualified
|| out_buffer.type.volatile_qualified)) || out_buffer.members.type.volatile_qualified))
out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr; out_buffer.members.obj_ptr = in_buffer.members.obj_ref.obj_ptr;
else else
out_buffer.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} }
return; return;
case get_functor_type_tag: case get_functor_type_tag:
out_buffer.type.type = &boost::typeindex::type_id<F>().type_info(); out_buffer.members.type.type = &boost::typeindex::type_id<F>().type_info();
out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified; out_buffer.members.type.const_qualified = in_buffer.members.obj_ref.is_const_qualified;
out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified; out_buffer.members.type.volatile_qualified = in_buffer.members.obj_ref.is_volatile_qualified;
return; return;
} }
} }
@ -252,21 +260,21 @@ namespace boost {
functor_manager_operation_type op) functor_manager_operation_type op)
{ {
if (op == clone_functor_tag) if (op == clone_functor_tag)
out_buffer.func_ptr = in_buffer.func_ptr; out_buffer.members.func_ptr = in_buffer.members.func_ptr;
else if (op == move_functor_tag) { else if (op == move_functor_tag) {
out_buffer.func_ptr = in_buffer.func_ptr; out_buffer.members.func_ptr = in_buffer.members.func_ptr;
in_buffer.func_ptr = 0; in_buffer.members.func_ptr = 0;
} else if (op == destroy_functor_tag) } else if (op == destroy_functor_tag)
out_buffer.func_ptr = 0; out_buffer.members.func_ptr = 0;
else if (op == check_functor_type_tag) { else if (op == check_functor_type_tag) {
if (*out_buffer.type.type == boost::typeindex::type_id<Functor>()) if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
out_buffer.obj_ptr = &in_buffer.func_ptr; out_buffer.members.obj_ptr = &in_buffer.members.func_ptr;
else else
out_buffer.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} else /* op == get_functor_type_tag */ { } else /* op == get_functor_type_tag */ {
out_buffer.type.type = &boost::typeindex::type_id<Functor>().type_info(); out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
out_buffer.type.const_qualified = false; out_buffer.members.type.const_qualified = false;
out_buffer.type.volatile_qualified = false; out_buffer.members.type.volatile_qualified = false;
} }
} }
@ -277,28 +285,28 @@ namespace boost {
{ {
if (op == clone_functor_tag || op == move_functor_tag) { if (op == clone_functor_tag || op == move_functor_tag) {
const functor_type* in_functor = const functor_type* in_functor =
reinterpret_cast<const functor_type*>(&in_buffer.data); reinterpret_cast<const functor_type*>(in_buffer.data);
new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor); new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor);
if (op == move_functor_tag) { if (op == move_functor_tag) {
functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data); functor_type* f = reinterpret_cast<functor_type*>(in_buffer.data);
(void)f; // suppress warning about the value of f not being used (MSVC) (void)f; // suppress warning about the value of f not being used (MSVC)
f->~Functor(); f->~Functor();
} }
} else if (op == destroy_functor_tag) { } else if (op == destroy_functor_tag) {
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type. // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data); functor_type* f = reinterpret_cast<functor_type*>(out_buffer.data);
(void)f; // suppress warning about the value of f not being used (MSVC) (void)f; // suppress warning about the value of f not being used (MSVC)
f->~Functor(); f->~Functor();
} else if (op == check_functor_type_tag) { } else if (op == check_functor_type_tag) {
if (*out_buffer.type.type == boost::typeindex::type_id<Functor>()) if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
out_buffer.obj_ptr = &in_buffer.data; out_buffer.members.obj_ptr = in_buffer.data;
else else
out_buffer.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} else /* op == get_functor_type_tag */ { } else /* op == get_functor_type_tag */ {
out_buffer.type.type = &boost::typeindex::type_id<Functor>().type_info(); out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
out_buffer.type.const_qualified = false; out_buffer.members.type.const_qualified = false;
out_buffer.type.volatile_qualified = false; out_buffer.members.type.volatile_qualified = false;
} }
} }
}; };
@ -337,27 +345,27 @@ namespace boost {
// jewillco: Changing this to static_cast because GCC 2.95.3 is // jewillco: Changing this to static_cast because GCC 2.95.3 is
// obsolete. // obsolete.
const functor_type* f = const functor_type* f =
static_cast<const functor_type*>(in_buffer.obj_ptr); static_cast<const functor_type*>(in_buffer.members.obj_ptr);
functor_type* new_f = new functor_type(*f); functor_type* new_f = new functor_type(*f);
out_buffer.obj_ptr = new_f; out_buffer.members.obj_ptr = new_f;
} else if (op == move_functor_tag) { } else if (op == move_functor_tag) {
out_buffer.obj_ptr = in_buffer.obj_ptr; out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
in_buffer.obj_ptr = 0; in_buffer.members.obj_ptr = 0;
} else if (op == destroy_functor_tag) { } else if (op == destroy_functor_tag) {
/* Cast from the void pointer to the functor pointer type */ /* Cast from the void pointer to the functor pointer type */
functor_type* f = functor_type* f =
static_cast<functor_type*>(out_buffer.obj_ptr); static_cast<functor_type*>(out_buffer.members.obj_ptr);
delete f; delete f;
out_buffer.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} else if (op == check_functor_type_tag) { } else if (op == check_functor_type_tag) {
if (*out_buffer.type.type == boost::typeindex::type_id<Functor>()) if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
out_buffer.obj_ptr = in_buffer.obj_ptr; out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
else else
out_buffer.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} else /* op == get_functor_type_tag */ { } else /* op == get_functor_type_tag */ {
out_buffer.type.type = &boost::typeindex::type_id<Functor>().type_info(); out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
out_buffer.type.const_qualified = false; out_buffer.members.type.const_qualified = false;
out_buffer.type.volatile_qualified = false; out_buffer.members.type.volatile_qualified = false;
} }
} }
@ -390,9 +398,9 @@ namespace boost {
typedef typename get_function_tag<functor_type>::type tag_type; typedef typename get_function_tag<functor_type>::type tag_type;
switch (op) { switch (op) {
case get_functor_type_tag: case get_functor_type_tag:
out_buffer.type.type = &boost::typeindex::type_id<functor_type>().type_info(); out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
out_buffer.type.const_qualified = false; out_buffer.members.type.const_qualified = false;
out_buffer.type.volatile_qualified = false; out_buffer.members.type.volatile_qualified = false;
return; return;
default: default:
@ -439,34 +447,34 @@ namespace boost {
// GCC 2.95.3 gets the CV qualifiers wrong here, so we // GCC 2.95.3 gets the CV qualifiers wrong here, so we
// can't do the static_cast that we should do. // can't do the static_cast that we should do.
const functor_wrapper_type* f = const functor_wrapper_type* f =
static_cast<const functor_wrapper_type*>(in_buffer.obj_ptr); static_cast<const functor_wrapper_type*>(in_buffer.members.obj_ptr);
wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f)); wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1); wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
wrapper_allocator.construct(copy, *f); wrapper_allocator.construct(copy, *f);
// Get back to the original pointer type // Get back to the original pointer type
functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy); functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
out_buffer.obj_ptr = new_f; out_buffer.members.obj_ptr = new_f;
} else if (op == move_functor_tag) { } else if (op == move_functor_tag) {
out_buffer.obj_ptr = in_buffer.obj_ptr; out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
in_buffer.obj_ptr = 0; in_buffer.members.obj_ptr = 0;
} else if (op == destroy_functor_tag) { } else if (op == destroy_functor_tag) {
/* Cast from the void pointer to the functor_wrapper_type */ /* Cast from the void pointer to the functor_wrapper_type */
functor_wrapper_type* victim = functor_wrapper_type* victim =
static_cast<functor_wrapper_type*>(in_buffer.obj_ptr); static_cast<functor_wrapper_type*>(in_buffer.members.obj_ptr);
wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim)); wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
wrapper_allocator.destroy(victim); wrapper_allocator.destroy(victim);
wrapper_allocator.deallocate(victim,1); wrapper_allocator.deallocate(victim,1);
out_buffer.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} else if (op == check_functor_type_tag) { } else if (op == check_functor_type_tag) {
if (*out_buffer.type.type == boost::typeindex::type_id<Functor>()) if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
out_buffer.obj_ptr = in_buffer.obj_ptr; out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
else else
out_buffer.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} else /* op == get_functor_type_tag */ { } else /* op == get_functor_type_tag */ {
out_buffer.type.type = &boost::typeindex::type_id<Functor>().type_info(); out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
out_buffer.type.const_qualified = false; out_buffer.members.type.const_qualified = false;
out_buffer.type.volatile_qualified = false; out_buffer.members.type.volatile_qualified = false;
} }
} }
@ -491,9 +499,9 @@ namespace boost {
typedef typename get_function_tag<functor_type>::type tag_type; typedef typename get_function_tag<functor_type>::type tag_type;
switch (op) { switch (op) {
case get_functor_type_tag: case get_functor_type_tag:
out_buffer.type.type = &boost::typeindex::type_id<functor_type>().type_info(); out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
out_buffer.type.const_qualified = false; out_buffer.members.type.const_qualified = false;
out_buffer.type.volatile_qualified = false; out_buffer.members.type.volatile_qualified = false;
return; return;
default: default:
@ -600,7 +608,7 @@ public:
detail::function::function_buffer type; detail::function::function_buffer type;
get_vtable()->manager(functor, type, detail::function::get_functor_type_tag); get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
return *type.type.type; return *type.members.type.type;
} }
template<typename Functor> template<typename Functor>
@ -609,12 +617,12 @@ public:
if (!vtable) return 0; if (!vtable) return 0;
detail::function::function_buffer type_result; detail::function::function_buffer type_result;
type_result.type.type = &boost::typeindex::type_id<Functor>().type_info(); type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
type_result.type.const_qualified = is_const<Functor>::value; type_result.members.type.const_qualified = is_const<Functor>::value;
type_result.type.volatile_qualified = is_volatile<Functor>::value; type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
get_vtable()->manager(functor, type_result, get_vtable()->manager(functor, type_result,
detail::function::check_functor_type_tag); detail::function::check_functor_type_tag);
return static_cast<Functor*>(type_result.obj_ptr); return static_cast<Functor*>(type_result.members.obj_ptr);
} }
template<typename Functor> template<typename Functor>
@ -623,14 +631,14 @@ public:
if (!vtable) return 0; if (!vtable) return 0;
detail::function::function_buffer type_result; detail::function::function_buffer type_result;
type_result.type.type = &boost::typeindex::type_id<Functor>().type_info(); type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
type_result.type.const_qualified = true; type_result.members.type.const_qualified = true;
type_result.type.volatile_qualified = is_volatile<Functor>::value; type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
get_vtable()->manager(functor, type_result, get_vtable()->manager(functor, type_result,
detail::function::check_functor_type_tag); detail::function::check_functor_type_tag);
// GCC 2.95.3 gets the CV qualifiers wrong here, so we // GCC 2.95.3 gets the CV qualifiers wrong here, so we
// can't do the static_cast that we should do. // can't do the static_cast that we should do.
return static_cast<const Functor*>(type_result.obj_ptr); return static_cast<const Functor*>(type_result.members.obj_ptr);
} }
template<typename F> template<typename F>

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

@ -97,7 +97,7 @@ namespace boost {
static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
BOOST_FUNCTION_PARMS) BOOST_FUNCTION_PARMS)
{ {
FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr); FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
return f(BOOST_FUNCTION_ARGS); return f(BOOST_FUNCTION_ARGS);
} }
}; };
@ -114,7 +114,7 @@ namespace boost {
BOOST_FUNCTION_PARMS) BOOST_FUNCTION_PARMS)
{ {
FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr); FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS)); BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
} }
}; };
@ -132,9 +132,9 @@ namespace boost {
{ {
FunctionObj* f; FunctionObj* f;
if (function_allows_small_object_optimization<FunctionObj>::value) if (function_allows_small_object_optimization<FunctionObj>::value)
f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data); f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
else else
f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr); f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
return (*f)(BOOST_FUNCTION_ARGS); return (*f)(BOOST_FUNCTION_ARGS);
} }
}; };
@ -153,9 +153,9 @@ namespace boost {
{ {
FunctionObj* f; FunctionObj* f;
if (function_allows_small_object_optimization<FunctionObj>::value) if (function_allows_small_object_optimization<FunctionObj>::value)
f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data); f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
else else
f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr); f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS)); BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
} }
}; };
@ -172,7 +172,7 @@ namespace boost {
{ {
FunctionObj* f = FunctionObj* f =
reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr); reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
return (*f)(BOOST_FUNCTION_ARGS); return (*f)(BOOST_FUNCTION_ARGS);
} }
}; };
@ -190,7 +190,7 @@ namespace boost {
{ {
FunctionObj* f = FunctionObj* f =
reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr); reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS)); BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
} }
}; };
@ -209,7 +209,7 @@ namespace boost {
{ {
MemberPtr* f = MemberPtr* f =
reinterpret_cast<MemberPtr*>(&function_obj_ptr.data); reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS); return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
} }
}; };
@ -227,7 +227,7 @@ namespace boost {
{ {
MemberPtr* f = MemberPtr* f =
reinterpret_cast<MemberPtr*>(&function_obj_ptr.data); reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS)); BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
} }
}; };
@ -520,7 +520,7 @@ namespace boost {
if (f) { if (f) {
// should be a reinterpret cast, but some compilers insist // should be a reinterpret cast, but some compilers insist
// on giving cv-qualifiers to free functions // on giving cv-qualifiers to free functions
functor.func_ptr = reinterpret_cast<void (*)()>(f); functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
return true; return true;
} else { } else {
return false; return false;
@ -569,7 +569,7 @@ namespace boost {
void void
assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
{ {
new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f); new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
} }
template<typename FunctionObj,typename Allocator> template<typename FunctionObj,typename Allocator>
void void
@ -583,7 +583,7 @@ namespace boost {
void void
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
{ {
functor.obj_ptr = new FunctionObj(f); functor.members.obj_ptr = new FunctionObj(f);
} }
template<typename FunctionObj,typename Allocator> template<typename FunctionObj,typename Allocator>
void void
@ -597,7 +597,7 @@ namespace boost {
wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1); wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
wrapper_allocator.construct(copy, functor_wrapper_type(f,a)); wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy); functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
functor.obj_ptr = new_f; functor.members.obj_ptr = new_f;
} }
template<typename FunctionObj> template<typename FunctionObj>
@ -631,9 +631,9 @@ namespace boost {
assign_to(const reference_wrapper<FunctionObj>& f, assign_to(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, function_obj_ref_tag) const function_buffer& functor, function_obj_ref_tag) const
{ {
functor.obj_ref.obj_ptr = (void *)(f.get_pointer()); functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value; functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value; functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
return true; return true;
} }
template<typename FunctionObj,typename Allocator> template<typename FunctionObj,typename Allocator>
@ -845,7 +845,6 @@ namespace boost {
// Move assignment from another BOOST_FUNCTION_FUNCTION // Move assignment from another BOOST_FUNCTION_FUNCTION
BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f) BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f)
{ {
if (&f == this) if (&f == this)
return *this; return *this;