summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '3rdParty/Boost/src/boost/function')
-rw-r--r--3rdParty/Boost/src/boost/function/function_base.hpp24
-rw-r--r--3rdParty/Boost/src/boost/function/function_template.hpp125
2 files changed, 91 insertions, 58 deletions
diff --git a/3rdParty/Boost/src/boost/function/function_base.hpp b/3rdParty/Boost/src/boost/function/function_base.hpp
index fe9bbbe..78b7dd1 100644
--- a/3rdParty/Boost/src/boost/function/function_base.hpp
+++ b/3rdParty/Boost/src/boost/function/function_base.hpp
@@ -203,11 +203,11 @@ namespace boost {
{
switch (op) {
case clone_functor_tag:
- out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
+ out_buffer.obj_ref = in_buffer.obj_ref;
return;
case move_functor_tag:
- out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
+ out_buffer.obj_ref = in_buffer.obj_ref;
in_buffer.obj_ref.obj_ptr = 0;
return;
@@ -315,14 +315,18 @@ 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 ((void*)&out_buffer.data) functor_type(*in_functor);
+ new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);
if (op == move_functor_tag) {
- reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor();
+ 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();
}
} else if (op == destroy_functor_tag) {
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
- reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
+ 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();
} else if (op == check_functor_type_tag) {
const detail::sp_typeinfo& check_type
= *out_buffer.type.type;
@@ -369,8 +373,10 @@ 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 =
- (const functor_type*)(in_buffer.obj_ptr);
+ static_cast<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) {
@@ -474,7 +480,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 =
- (const functor_wrapper_type*)(in_buffer.obj_ptr);
+ static_cast<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);
@@ -671,7 +677,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 (const Functor*)(type_result.obj_ptr);
+ return static_cast<const Functor*>(type_result.obj_ptr);
}
template<typename F>
@@ -715,7 +721,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) & ~(std::size_t)0x01);
+ reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
}
bool has_trivial_copy_and_destroy() const {
diff --git a/3rdParty/Boost/src/boost/function/function_template.hpp b/3rdParty/Boost/src/boost/function/function_template.hpp
index 6a99109..f9699d0 100644
--- a/3rdParty/Boost/src/boost/function/function_template.hpp
+++ b/3rdParty/Boost/src/boost/function/function_template.hpp
@@ -486,19 +486,19 @@ namespace boost {
BOOST_FUNCTION_TEMPLATE_ARGS);
template<typename F>
- bool assign_to(F f, function_buffer& functor)
+ bool assign_to(F f, function_buffer& functor) const
{
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)
+ bool assign_to_a(F f, function_buffer& functor, Allocator a) const
{
typedef typename get_function_tag<F>::type tag;
return assign_to_a(f, functor, a, tag());
}
- void clear(function_buffer& functor)
+ void clear(function_buffer& functor) const
{
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)
+ assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
{
this->clear(functor);
if (f) {
// should be a reinterpret cast, but some compilers insist
// on giving cv-qualifiers to free functions
- functor.func_ptr = (void (*)())(f);
+ functor.func_ptr = reinterpret_cast<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)
+ assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
{
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)
+ bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
{
// 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(mem_fn(f), functor);
+ this->assign_to(boost::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)
+ bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
{
// 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(mem_fn(f), functor, a);
+ this->assign_to_a(boost::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_)
+ assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
{
- new ((void*)&functor.data) FunctionObj(f);
+ new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
}
template<typename FunctionObj,typename Allocator>
void
- assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
+ assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
{
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_)
+ assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
{
functor.obj_ptr = new FunctionObj(f);
}
template<typename FunctionObj,typename Allocator>
void
- assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
+ assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
{
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)
+ assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
{
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)
+ assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
{
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)
+ function_buffer& functor, function_obj_ref_tag) const
{
- 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)
+ function_buffer& functor, Allocator, function_obj_ref_tag) const
{
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) & ~(std::size_t)0x01);
+ reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
}
struct clear_type {};
@@ -748,12 +748,16 @@ namespace boost {
{
this->assign_to_own(f);
}
-
+
+#ifndef BOOST_NO_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())
@@ -762,9 +766,6 @@ 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
@@ -836,6 +837,26 @@ namespace boost {
BOOST_CATCH_END
return *this;
}
+
+#ifndef BOOST_NO_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)
{
@@ -864,7 +885,7 @@ namespace boost {
#else
private:
struct dummy {
- void nonnull() {};
+ void nonnull() {}
};
typedef void (dummy::*safe_bool)();
@@ -909,7 +930,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 vtable_type stored_vtable =
+ static const vtable_type stored_vtable =
{ { &manager_type::manage }, &invoker_type::invoke };
if (stored_vtable.assign_to(f, functor)) {
@@ -917,7 +938,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 |= (std::size_t)0x01;
+ value |= static_cast<size_t>(0x01);
vtable = reinterpret_cast<detail::function::vtable_base *>(value);
} else
vtable = 0;
@@ -943,7 +964,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 vtable_type stored_vtable =
+ static const vtable_type stored_vtable =
{ { &manager_type::manage }, &invoker_type::invoke };
if (stored_vtable.assign_to_a(f, functor, a)) {
@@ -951,7 +972,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 |= (std::size_t)0x01;
+ value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<detail::function::vtable_base *>(value);
} else
vtable = 0;
@@ -998,22 +1019,6 @@ 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<
@@ -1085,12 +1090,26 @@ public:
function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+#ifndef BOOST_NO_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_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<
@@ -1119,6 +1138,14 @@ public:
self_type(f).swap(*this);
return *this;
}
+
+#ifndef BOOST_NO_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