c_cpp/boost
SHA256
8
0
Fork 0
forked from pool/boost
Code Pull Requests Activity

OBS-URL: https://build.opensuse.org/package/show/openSUSE:Factory/boost?expand=0&rev=11

Browse Source
This commit is contained in:
OBS User unknown
2008-01-30 16:55:59 +00:00
committed by Git OBS Bridge
parent bcc0fd3890
commit fc05f47b44
34 changed files with 2435 additions and 540 deletions
Download Patch File Download Diff File Expand all files Collapse all files

702
boost-Boost.Function.patch Normal file
View File

@@ -0,0 +1,702 @@
--- boost/function/function_base.hpp
+++ boost/function/function_base.hpp
@@ -15,6 +15,7 @@
#include <memory>
#include <new>
#include <typeinfo>
+#include <functional> // unary_function, binary_function
#include <boost/config.hpp>
#include <boost/assert.hpp>
#include <boost/type_traits/is_integral.hpp>
@@ -30,6 +31,20 @@
#endif
#include <boost/function_equal.hpp>
+#if defined(BOOST_MSVC)
+# pragma warning( push )
+# pragma warning( disable : 4793 ) // complaint about native code generation
+# pragma warning( disable : 4127 ) // "conditional expression is constant"
+#endif
+
+// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
+#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
+// Embedded VC++ does not have type_info in namespace std
+# define BOOST_FUNCTION_STD_NS
+#else
+# define BOOST_FUNCTION_STD_NS std
+#endif
+
// Borrowed from Boost.Python library: determines the cases where we
// need to use std::type_info::name to compare instead of operator==.
# if (defined(__GNUC__) && __GNUC__ >= 3) \
@@ -59,7 +74,7 @@
#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|| defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
- || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+ || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
# define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
#endif
@@ -198,8 +213,8 @@
struct reference_manager
{
static inline void
- get(const function_buffer& in_buffer, function_buffer& out_buffer,
- functor_manager_operation_type op)
+ manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+ functor_manager_operation_type op)
{
switch (op) {
case clone_functor_tag:
@@ -215,8 +230,8 @@
// DPG TBD: Since we're only storing a pointer, it's
// possible that the user could ask for a base class or
// derived class. Is that okay?
- const std::type_info& check_type =
- *static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
+ const BOOST_FUNCTION_STD_NS::type_info& check_type =
+ *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
out_buffer.obj_ptr = in_buffer.obj_ptr;
else
@@ -265,8 +280,8 @@
else if (op == destroy_functor_tag)
out_buffer.func_ptr = 0;
else /* op == check_functor_type_tag */ {
- const std::type_info& check_type =
- *static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
+ const BOOST_FUNCTION_STD_NS::type_info& check_type =
+ *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
out_buffer.obj_ptr = &in_buffer.func_ptr;
else
@@ -287,8 +302,8 @@
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
} else /* op == check_functor_type_tag */ {
- const std::type_info& check_type =
- *static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
+ const BOOST_FUNCTION_STD_NS::type_info& check_type =
+ *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
out_buffer.obj_ptr = &in_buffer.data;
else
@@ -348,8 +363,8 @@
# endif // BOOST_NO_STD_ALLOCATOR
out_buffer.obj_ptr = 0;
} else /* op == check_functor_type_tag */ {
- const std::type_info& check_type =
- *static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
+ const BOOST_FUNCTION_STD_NS::type_info& check_type =
+ *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
out_buffer.obj_ptr = in_buffer.obj_ptr;
else
@@ -368,6 +383,15 @@
mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
}
+ // For member pointers, we treat them as function objects with
+ // the small-object optimization always enabled.
+ static inline void
+ manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+ functor_manager_operation_type op, member_ptr_tag)
+ {
+ manager(in_buffer, out_buffer, op, mpl::true_());
+ }
+
public:
/* Dispatch to an appropriate manager based on whether we have a
function pointer or a function object pointer. */
@@ -456,7 +480,6 @@
*/
struct vtable_base
{
- vtable_base() : manager(0) { }
void (*manager)(const function_buffer& in_buffer,
function_buffer& out_buffer,
functor_manager_operation_type op);
@@ -480,13 +503,13 @@
/** Retrieve the type of the stored function object, or typeid(void)
if this is empty. */
- const std::type_info& target_type() const
+ const BOOST_FUNCTION_STD_NS::type_info& target_type() const
{
if (!vtable) return typeid(void);
detail::function::function_buffer type;
vtable->manager(functor, type, detail::function::get_functor_type_tag);
- return *static_cast<const std::type_info*>(type.const_obj_ptr);
+ return *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(type.const_obj_ptr);
}
template<typename Functor>
@@ -558,7 +581,7 @@
#endif
public: // should be protected, but GCC 2.95.3 will fail to allow access
- detail::function::vtable_base* vtable;
+ const detail::function::vtable_base* vtable;
mutable detail::function::function_buffer functor;
};
@@ -733,4 +756,8 @@
#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
#undef BOOST_FUNCTION_COMPARE_TYPE_ID
+#if defined(BOOST_MSVC)
+# pragma warning( pop )
+#endif
+
#endif // BOOST_FUNCTION_BASE_HEADER
--- boost/function/function_template.hpp
+++ boost/function/function_template.hpp
@@ -11,6 +11,11 @@
// protection.
#include <boost/function/detail/prologue.hpp>
+#if defined(BOOST_MSVC)
+# pragma warning( push )
+# pragma warning( disable : 4127 ) // "conditional expression is constant"
+#endif
+
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
@@ -54,12 +59,20 @@
BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_MEMBER_INVOKER \
+ BOOST_JOIN(member_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \
+ BOOST_JOIN(void_member_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER \
+ BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_GET_INVOKER \
+ BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
#ifndef BOOST_NO_VOID_RETURNS
@@ -70,16 +83,6 @@
# define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()
#endif
-#ifdef BOOST_MSVC
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant.
-#endif
-
-#ifdef BOOST_MSVC
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant.
-#endif
-
namespace boost {
namespace detail {
namespace function {
@@ -191,6 +194,44 @@
}
};
+#if BOOST_FUNCTION_NUM_ARGS > 0
+ /* Handle invocation of member pointers. */
+ template<
+ typename MemberPtr,
+ typename R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_PARMS
+ >
+ struct BOOST_FUNCTION_MEMBER_INVOKER
+ {
+ static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_PARMS)
+
+ {
+ MemberPtr* f =
+ reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+ return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
+ }
+ };
+
+ template<
+ typename MemberPtr,
+ typename R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_PARMS
+ >
+ struct BOOST_FUNCTION_VOID_MEMBER_INVOKER
+ {
+ static BOOST_FUNCTION_VOID_RETURN_TYPE
+ invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_PARMS)
+
+ {
+ MemberPtr* f =
+ reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+ BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
+ }
+ };
+#endif
+
template<
typename FunctionPtr,
typename R BOOST_FUNCTION_COMMA
@@ -254,12 +295,130 @@
>::type type;
};
+#if BOOST_FUNCTION_NUM_ARGS > 0
+ /* Retrieve the appropriate invoker for a member pointer. */
+ template<
+ typename MemberPtr,
+ typename R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_PARMS
+ >
+ struct BOOST_FUNCTION_GET_MEMBER_INVOKER
+ {
+ typedef typename mpl::if_c<(is_void<R>::value),
+ BOOST_FUNCTION_VOID_MEMBER_INVOKER<
+ MemberPtr,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >,
+ BOOST_FUNCTION_MEMBER_INVOKER<
+ MemberPtr,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >
+ >::type type;
+ };
+#endif
+
+ /* Given the tag returned by get_function_tag, retrieve the
+ actual invoker that will be used for the given function
+ object.
+
+ Each specialization contains an "apply" nested class template
+ that accepts the function object, return type, function
+ argument types, and allocator. The resulting "apply" class
+ contains two typedefs, "invoker_type" and "manager_type",
+ which correspond to the invoker and manager types. */
+ template<typename Tag>
+ struct BOOST_FUNCTION_GET_INVOKER { };
+
+ /* Retrieve the invoker for a function pointer. */
+ template<>
+ struct BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
+ {
+ template<typename FunctionPtr,
+ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+ typename Allocator>
+ struct apply
+ {
+ typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+ FunctionPtr,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ invoker_type;
+
+ typedef functor_manager<FunctionPtr, Allocator> manager_type;
+ };
+ };
+
+#if BOOST_FUNCTION_NUM_ARGS > 0
+ /* Retrieve the invoker for a member pointer. */
+ template<>
+ struct BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
+ {
+ template<typename MemberPtr,
+ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+ typename Allocator>
+ struct apply
+ {
+ typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
+ MemberPtr,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ invoker_type;
+
+ typedef functor_manager<MemberPtr, Allocator> manager_type;
+ };
+ };
+#endif
+
+ /* Retrieve the invoker for a function object. */
+ template<>
+ struct BOOST_FUNCTION_GET_INVOKER<function_obj_tag>
+ {
+ template<typename FunctionObj,
+ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+ typename Allocator>
+ struct apply
+ {
+ typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+ FunctionObj,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ invoker_type;
+
+ typedef functor_manager<FunctionObj, Allocator> manager_type;
+ };
+ };
+
+ /* Retrieve the invoker for a reference to a function object. */
+ template<>
+ struct BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
+ {
+ template<typename RefWrapper,
+ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+ typename Allocator>
+ struct apply
+ {
+ typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
+ typename RefWrapper::type,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ invoker_type;
+
+ typedef reference_manager<typename RefWrapper::type> manager_type;
+ };
+ };
+
/**
* vtable for a specific boost::function instance.
*/
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
typename Allocator>
- struct BOOST_FUNCTION_VTABLE : vtable_base
+ struct BOOST_FUNCTION_VTABLE
{
#ifndef BOOST_NO_VOID_RETURNS
typedef R result_type;
@@ -272,50 +431,25 @@
BOOST_FUNCTION_TEMPLATE_ARGS);
template<typename F>
- BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0)
- {
- init(f);
- }
-
- template<typename F>
- bool assign_to(F f, function_buffer& functor)
+ bool assign_to(const F& f, function_buffer& functor) const
{
typedef typename get_function_tag<F>::type tag;
return assign_to(f, functor, tag());
}
- void clear(function_buffer& functor)
+ void clear(function_buffer& functor) const
{
- if (manager)
- manager(functor, functor, destroy_functor_tag);
+ if (base.manager)
+ base.manager(functor, functor, destroy_functor_tag);
}
-
+#ifndef BOOST_NO_PRIVATE_IN_AGGREGATE
private:
- template<typename F>
- void init(F f)
- {
- typedef typename get_function_tag<F>::type tag;
- init(f, tag());
- }
-
+#endif
// Function pointers
template<typename FunctionPtr>
- void init(FunctionPtr /*f*/, function_ptr_tag)
- {
- typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
- FunctionPtr,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >::type
- actual_invoker_type;
-
- invoker = &actual_invoker_type::invoke;
- manager = &functor_manager<FunctionPtr, Allocator>::manage;
- }
-
- 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) {
@@ -331,22 +465,13 @@
// Member pointers
#if BOOST_FUNCTION_NUM_ARGS > 0
template<typename MemberPtr>
- void init(MemberPtr f, 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.
- this->init(mem_fn(f));
- }
-
- 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);
+ // Always use the small-object optimization for member
+ // pointers.
+ assign_functor(f, functor, mpl::true_());
return true;
} else {
return false;
@@ -355,24 +480,11 @@
#endif // BOOST_FUNCTION_NUM_ARGS > 0
// Function objects
- template<typename FunctionObj>
- void init(FunctionObj /*f*/, function_obj_tag)
- {
- typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
- FunctionObj,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >::type
- actual_invoker_type;
-
- invoker = &actual_invoker_type::invoke;
- manager = &functor_manager<FunctionObj, Allocator>::manage;
- }
-
// 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(const FunctionObj& f, function_buffer& functor,
+ mpl::true_) const
{
new ((void*)&functor.data) FunctionObj(f);
}
@@ -380,7 +492,8 @@
// Assign to a function object allocated on the heap.
template<typename FunctionObj>
void
- assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
+ assign_functor(const FunctionObj& f, function_buffer& functor,
+ mpl::false_) const
{
#ifndef BOOST_NO_STD_ALLOCATOR
typedef typename Allocator::template rebind<FunctionObj>::other
@@ -400,7 +513,8 @@
template<typename FunctionObj>
bool
- assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
+ assign_to(const FunctionObj& f, function_buffer& functor,
+ function_obj_tag) const
{
if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
assign_functor(f, functor,
@@ -413,24 +527,9 @@
// Reference to a function object
template<typename FunctionObj>
- void
- init(const reference_wrapper<FunctionObj>& /*f*/, function_obj_ref_tag)
- {
- typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
- FunctionObj,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >::type
- actual_invoker_type;
-
- invoker = &actual_invoker_type::invoke;
- manager = &reference_manager<FunctionObj>::get;
- }
-
- 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
{
if (!boost::detail::function::has_empty_target(f.get_pointer())) {
// DPG TBD: We might need to detect constness of
@@ -445,6 +544,7 @@
}
public:
+ vtable_base base;
invoker_type invoker;
};
} // end namespace function
@@ -456,6 +556,17 @@
typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR
>
class BOOST_FUNCTION_FUNCTION : public function_base
+
+#if BOOST_FUNCTION_NUM_ARGS == 1
+
+ , public std::unary_function<T0,R>
+
+#elif BOOST_FUNCTION_NUM_ARGS == 2
+
+ , public std::binary_function<T0,T1,R>
+
+#endif
+
{
public:
#ifndef BOOST_NO_VOID_RETURNS
@@ -537,7 +648,7 @@
if (this->empty())
boost::throw_exception(bad_function_call());
- return static_cast<vtable_type*>(vtable)->invoker
+ return reinterpret_cast<const vtable_type*>(vtable)->invoker
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
}
#else
@@ -561,12 +672,16 @@
operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
{
this->clear();
+#ifndef BOOST_NO_EXCEPTIONS
try {
this->assign_to(f);
} catch (...) {
vtable = 0;
throw;
}
+#else
+ this->assign_to(f);
+#endif
return *this;
}
@@ -592,12 +707,16 @@
return *this;
this->clear();
+#ifndef BOOST_NO_EXCEPTIONS
try {
this->assign_to_own(f);
} catch (...) {
vtable = 0;
throw;
}
+#else
+ this->assign_to_own(f);
+#endif
return *this;
}
@@ -615,7 +734,7 @@
void clear()
{
if (vtable) {
- static_cast<vtable_type*>(vtable)->clear(this->functor);
+ reinterpret_cast<const vtable_type*>(vtable)->clear(this->functor);
vtable = 0;
}
}
@@ -650,10 +769,24 @@
}
template<typename Functor>
- void assign_to(Functor f)
+ void assign_to(const Functor& f)
{
- static vtable_type stored_vtable(f);
- if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable;
+ using detail::function::vtable_base;
+
+ typedef typename detail::function::get_function_tag<Functor>::type tag;
+ typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+ typedef typename get_invoker::
+ template apply<Functor, R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS, Allocator>
+ handler_type;
+
+ typedef typename handler_type::invoker_type invoker_type;
+ typedef typename handler_type::manager_type manager_type;
+
+ static const vtable_type stored_vtable =
+ { { &manager_type::manage }, &invoker_type::invoke };
+
+ if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable.base;
else vtable = 0;
}
};
@@ -688,7 +821,7 @@
if (this->empty())
boost::throw_exception(bad_function_call());
- return static_cast<vtable_type*>(vtable)->invoker
+ return reinterpret_cast<const vtable_type*>(vtable)->invoker
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
}
#endif
@@ -798,21 +931,14 @@
}
};
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif
-
#undef BOOST_FUNCTION_PARTIAL_SPEC
#endif // have partial specialization
} // end namespace boost
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif
-
// Cleanup after ourselves...
#undef BOOST_FUNCTION_VTABLE
+#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_DEFAULT_ALLOCATOR
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
@@ -822,10 +948,12 @@
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
-#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_MEMBER_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
@@ -835,3 +963,7 @@
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
+
+#if defined(BOOST_MSVC)
+# pragma warning( pop )
+#endif