forked from boostorg/function
Compare commits
1 Commits
svn-branch
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
| 98a207958d |
@ -6,11 +6,5 @@
|
||||
project boost/doc ;
|
||||
import boostbook : boostbook ;
|
||||
|
||||
boostbook function-doc
|
||||
:
|
||||
function.xml
|
||||
:
|
||||
<xsl:param>boost.root=../../../..
|
||||
<format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
|
||||
;
|
||||
boostbook function-doc : function.xml ;
|
||||
|
||||
|
||||
@ -35,12 +35,12 @@ form to use for your compiler.
|
||||
<row>
|
||||
<entry>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><simpara>GNU C++ 2.95.x, 3.0.x and later versions</simpara></listitem>
|
||||
<listitem><simpara>GNU C++ 2.95.x, 3.0.x, 3.1.x</simpara></listitem>
|
||||
<listitem><simpara>Comeau C++ 4.2.45.2</simpara></listitem>
|
||||
<listitem><simpara>SGI MIPSpro 7.3.0</simpara></listitem>
|
||||
<listitem><simpara>Intel C++ 5.0, 6.0</simpara></listitem>
|
||||
<listitem><simpara>Compaq's cxx 6.2</simpara></listitem>
|
||||
<listitem><simpara>Microsoft Visual C++ 7.1 and later versions</simpara></listitem>
|
||||
<listitem><simpara>Microsoft Visual C++ 7.1</simpara></listitem>
|
||||
</itemizedlist>
|
||||
</entry>
|
||||
<entry>
|
||||
|
||||
@ -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
|
||||
|
||||
@ -15,12 +15,9 @@
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include <new>
|
||||
#include <typeinfo>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/sp_typeinfo.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/type_traits/has_trivial_copy.hpp>
|
||||
#include <boost/type_traits/has_trivial_destructor.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
#include <boost/type_traits/is_integral.hpp>
|
||||
#include <boost/type_traits/is_volatile.hpp>
|
||||
@ -45,7 +42,7 @@
|
||||
#endif
|
||||
|
||||
// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
|
||||
#ifdef BOOST_NO_STD_TYPEINFO
|
||||
#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
|
||||
// Embedded VC++ does not have type_info in namespace std
|
||||
# define BOOST_FUNCTION_STD_NS
|
||||
#else
|
||||
@ -54,9 +51,7 @@
|
||||
|
||||
// Borrowed from Boost.Python library: determines the cases where we
|
||||
// need to use std::type_info::name to compare instead of operator==.
|
||||
#if defined( BOOST_NO_TYPEID )
|
||||
# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
|
||||
#elif (defined(__GNUC__) && __GNUC__ >= 3) \
|
||||
# if (defined(__GNUC__) && __GNUC__ >= 3) \
|
||||
|| defined(_AIX) \
|
||||
|| ( defined(__sgi) && defined(__host_mips))
|
||||
# include <cstring>
|
||||
@ -105,7 +100,7 @@ namespace boost {
|
||||
// For pointers to std::type_info objects
|
||||
struct type_t {
|
||||
// (get_functor_type_tag, check_functor_type_tag).
|
||||
const detail::sp_typeinfo* type;
|
||||
const BOOST_FUNCTION_STD_NS::type_info* type;
|
||||
|
||||
// Whether the type is const-qualified.
|
||||
bool const_qualified;
|
||||
@ -198,16 +193,16 @@ namespace boost {
|
||||
struct reference_manager
|
||||
{
|
||||
static inline void
|
||||
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
get(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
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;
|
||||
|
||||
@ -217,12 +212,12 @@ namespace boost {
|
||||
|
||||
case check_functor_type_tag:
|
||||
{
|
||||
const detail::sp_typeinfo& check_type
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type
|
||||
= *out_buffer.type.type;
|
||||
|
||||
// Check whether we have the same type. We can add
|
||||
// cv-qualifiers, but we can't take them away.
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(F))
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F))
|
||||
&& (!in_buffer.obj_ref.is_const_qualified
|
||||
|| out_buffer.type.const_qualified)
|
||||
&& (!in_buffer.obj_ref.is_volatile_qualified
|
||||
@ -234,7 +229,7 @@ namespace boost {
|
||||
return;
|
||||
|
||||
case get_functor_type_tag:
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(F);
|
||||
out_buffer.type.type = &typeid(F);
|
||||
out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
|
||||
out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
|
||||
return;
|
||||
@ -264,12 +259,6 @@ namespace boost {
|
||||
A(a)
|
||||
{
|
||||
}
|
||||
|
||||
functor_wrapper(const functor_wrapper& f) :
|
||||
F(static_cast<const F&>(f)),
|
||||
A(static_cast<const A&>(f))
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
@ -294,14 +283,14 @@ namespace boost {
|
||||
} else if (op == destroy_functor_tag)
|
||||
out_buffer.func_ptr = 0;
|
||||
else if (op == check_functor_type_tag) {
|
||||
const detail::sp_typeinfo& check_type
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type
|
||||
= *out_buffer.type.type;
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = &in_buffer.func_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else /* op == get_functor_type_tag */ {
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
|
||||
out_buffer.type.type = &typeid(Functor);
|
||||
out_buffer.type.const_qualified = false;
|
||||
out_buffer.type.volatile_qualified = false;
|
||||
}
|
||||
@ -315,27 +304,23 @@ 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
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type
|
||||
= *out_buffer.type.type;
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = &in_buffer.data;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else /* op == get_functor_type_tag */ {
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
|
||||
out_buffer.type.type = &typeid(Functor);
|
||||
out_buffer.type.const_qualified = false;
|
||||
out_buffer.type.volatile_qualified = false;
|
||||
}
|
||||
@ -373,10 +358,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) {
|
||||
@ -389,14 +372,14 @@ namespace boost {
|
||||
delete f;
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else if (op == check_functor_type_tag) {
|
||||
const detail::sp_typeinfo& check_type
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type
|
||||
= *out_buffer.type.type;
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else /* op == get_functor_type_tag */ {
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
|
||||
out_buffer.type.type = &typeid(Functor);
|
||||
out_buffer.type.const_qualified = false;
|
||||
out_buffer.type.volatile_qualified = false;
|
||||
}
|
||||
@ -413,14 +396,6 @@ namespace boost {
|
||||
mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
|
||||
}
|
||||
|
||||
// For member pointers, we use the small-object optimization buffer.
|
||||
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. */
|
||||
@ -431,7 +406,7 @@ namespace boost {
|
||||
typedef typename get_function_tag<functor_type>::type tag_type;
|
||||
switch (op) {
|
||||
case get_functor_type_tag:
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
|
||||
out_buffer.type.type = &typeid(functor_type);
|
||||
out_buffer.type.const_qualified = false;
|
||||
out_buffer.type.volatile_qualified = false;
|
||||
return;
|
||||
@ -480,7 +455,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);
|
||||
@ -500,14 +475,14 @@ namespace boost {
|
||||
wrapper_allocator.deallocate(victim,1);
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else if (op == check_functor_type_tag) {
|
||||
const detail::sp_typeinfo& check_type
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type
|
||||
= *out_buffer.type.type;
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else /* op == get_functor_type_tag */ {
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
|
||||
out_buffer.type.type = &typeid(Functor);
|
||||
out_buffer.type.const_qualified = false;
|
||||
out_buffer.type.volatile_qualified = false;
|
||||
}
|
||||
@ -534,7 +509,7 @@ namespace boost {
|
||||
typedef typename get_function_tag<functor_type>::type tag_type;
|
||||
switch (op) {
|
||||
case get_functor_type_tag:
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
|
||||
out_buffer.type.type = &typeid(functor_type);
|
||||
out_buffer.type.const_qualified = false;
|
||||
out_buffer.type.volatile_qualified = false;
|
||||
return;
|
||||
@ -614,6 +589,7 @@ namespace boost {
|
||||
*/
|
||||
struct vtable_base
|
||||
{
|
||||
vtable_base() : manager(0) { }
|
||||
void (*manager)(const function_buffer& in_buffer,
|
||||
function_buffer& out_buffer,
|
||||
functor_manager_operation_type op);
|
||||
@ -635,14 +611,14 @@ public:
|
||||
/** Determine if the function is empty (i.e., has no target). */
|
||||
bool empty() const { return !vtable; }
|
||||
|
||||
/** Retrieve the type of the stored function object, or BOOST_SP_TYPEID(void)
|
||||
/** Retrieve the type of the stored function object, or typeid(void)
|
||||
if this is empty. */
|
||||
const detail::sp_typeinfo& target_type() const
|
||||
const BOOST_FUNCTION_STD_NS::type_info& target_type() const
|
||||
{
|
||||
if (!vtable) return BOOST_SP_TYPEID(void);
|
||||
if (!vtable) return typeid(void);
|
||||
|
||||
detail::function::function_buffer type;
|
||||
get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
|
||||
vtable->manager(functor, type, detail::function::get_functor_type_tag);
|
||||
return *type.type.type;
|
||||
}
|
||||
|
||||
@ -652,10 +628,10 @@ public:
|
||||
if (!vtable) return 0;
|
||||
|
||||
detail::function::function_buffer type_result;
|
||||
type_result.type.type = &BOOST_SP_TYPEID(Functor);
|
||||
type_result.type.type = &typeid(Functor);
|
||||
type_result.type.const_qualified = is_const<Functor>::value;
|
||||
type_result.type.volatile_qualified = is_volatile<Functor>::value;
|
||||
get_vtable()->manager(functor, type_result,
|
||||
vtable->manager(functor, type_result,
|
||||
detail::function::check_functor_type_tag);
|
||||
return static_cast<Functor*>(type_result.obj_ptr);
|
||||
}
|
||||
@ -670,14 +646,14 @@ public:
|
||||
if (!vtable) return 0;
|
||||
|
||||
detail::function::function_buffer type_result;
|
||||
type_result.type.type = &BOOST_SP_TYPEID(Functor);
|
||||
type_result.type.type = &typeid(Functor);
|
||||
type_result.type.const_qualified = true;
|
||||
type_result.type.volatile_qualified = is_volatile<Functor>::value;
|
||||
get_vtable()->manager(functor, type_result,
|
||||
vtable->manager(functor, type_result,
|
||||
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>
|
||||
@ -719,15 +695,6 @@ public:
|
||||
#endif
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
bool has_trivial_copy_and_destroy() const {
|
||||
return reinterpret_cast<std::size_t>(vtable) & 0x01;
|
||||
}
|
||||
|
||||
detail::function::vtable_base* vtable;
|
||||
mutable detail::function::function_buffer functor;
|
||||
};
|
||||
@ -903,8 +870,4 @@ namespace detail {
|
||||
#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
|
||||
|
||||
@ -21,7 +21,7 @@ namespace boost { namespace python { namespace objects {
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|
||||
|| defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
|
||||
|| !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
|
||||
|| !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
|
||||
# define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
|
||||
#endif
|
||||
|
||||
|
||||
@ -11,7 +11,6 @@
|
||||
// Note: this header is a header template and must NOT have multiple-inclusion
|
||||
// protection.
|
||||
#include <boost/function/detail/prologue.hpp>
|
||||
#include <boost/detail/no_exceptions_support.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning( push )
|
||||
@ -54,20 +53,12 @@
|
||||
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(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \
|
||||
BOOST_JOIN(function_void_mem_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
|
||||
@ -189,44 +180,6 @@ namespace boost {
|
||||
}
|
||||
};
|
||||
|
||||
#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
|
||||
@ -290,190 +243,11 @@ namespace boost {
|
||||
>::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>
|
||||
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> manager_type;
|
||||
};
|
||||
|
||||
template<typename FunctionPtr,
|
||||
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||
typename Allocator>
|
||||
struct apply_a
|
||||
{
|
||||
typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
|
||||
FunctionPtr,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
invoker_type;
|
||||
|
||||
typedef functor_manager<FunctionPtr> 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>
|
||||
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> manager_type;
|
||||
};
|
||||
|
||||
template<typename MemberPtr,
|
||||
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||
typename Allocator>
|
||||
struct apply_a
|
||||
{
|
||||
typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
|
||||
MemberPtr,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
invoker_type;
|
||||
|
||||
typedef functor_manager<MemberPtr> 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>
|
||||
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> manager_type;
|
||||
};
|
||||
|
||||
template<typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||
typename Allocator>
|
||||
struct apply_a
|
||||
{
|
||||
typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
invoker_type;
|
||||
|
||||
typedef functor_manager_a<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>
|
||||
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;
|
||||
};
|
||||
|
||||
template<typename RefWrapper,
|
||||
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||
typename Allocator>
|
||||
struct apply_a
|
||||
{
|
||||
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. This
|
||||
* structure must be an aggregate so that we can use static
|
||||
* initialization in boost::function's assign_to and assign_to_a
|
||||
* members. It therefore cannot have any constructors,
|
||||
* destructors, base classes, etc.
|
||||
* vtable for a specific boost::function instance.
|
||||
*/
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||
struct BOOST_FUNCTION_VTABLE
|
||||
struct BOOST_FUNCTION_VTABLE : vtable_base
|
||||
{
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
typedef R result_type;
|
||||
@ -485,6 +259,17 @@ namespace boost {
|
||||
BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS);
|
||||
|
||||
template<typename F>
|
||||
BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0)
|
||||
{
|
||||
init(f);
|
||||
}
|
||||
template<typename F,typename Allocator>
|
||||
BOOST_FUNCTION_VTABLE(F f, Allocator) : vtable_base(), invoker(0)
|
||||
{
|
||||
init_a<Allocator>(f);
|
||||
}
|
||||
|
||||
template<typename F>
|
||||
bool assign_to(F f, function_buffer& functor)
|
||||
{
|
||||
@ -500,12 +285,52 @@ namespace boost {
|
||||
|
||||
void clear(function_buffer& functor)
|
||||
{
|
||||
if (base.manager)
|
||||
base.manager(functor, functor, destroy_functor_tag);
|
||||
if (manager)
|
||||
manager(functor, functor, destroy_functor_tag);
|
||||
}
|
||||
|
||||
private:
|
||||
template<typename F>
|
||||
void init(F f)
|
||||
{
|
||||
typedef typename get_function_tag<F>::type tag;
|
||||
init(f, tag());
|
||||
}
|
||||
template<typename Allocator,typename F>
|
||||
void init_a(F f)
|
||||
{
|
||||
typedef typename get_function_tag<F>::type tag;
|
||||
init_a<Allocator>(f, tag());
|
||||
}
|
||||
|
||||
// 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>::manage;
|
||||
}
|
||||
template<typename Allocator,typename FunctionPtr>
|
||||
void init_a(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_a<FunctionPtr, Allocator>::manage;
|
||||
}
|
||||
|
||||
template<typename FunctionPtr>
|
||||
bool
|
||||
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
|
||||
@ -514,7 +339,7 @@ namespace boost {
|
||||
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;
|
||||
@ -529,6 +354,23 @@ namespace boost {
|
||||
|
||||
// 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 Allocator,typename MemberPtr>
|
||||
void init_a(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_a<Allocator>(mem_fn(f));
|
||||
}
|
||||
|
||||
template<typename MemberPtr>
|
||||
bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
|
||||
{
|
||||
@ -536,7 +378,7 @@ namespace boost {
|
||||
// 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;
|
||||
@ -549,7 +391,7 @@ namespace boost {
|
||||
// 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;
|
||||
@ -558,12 +400,39 @@ namespace boost {
|
||||
#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>::manage;
|
||||
}
|
||||
template<typename Allocator,typename FunctionObj>
|
||||
void init_a(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_a<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_)
|
||||
{
|
||||
new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
|
||||
new ((void*)&functor.data) FunctionObj(f);
|
||||
}
|
||||
template<typename FunctionObj,typename Allocator>
|
||||
void
|
||||
@ -620,15 +489,40 @@ namespace boost {
|
||||
}
|
||||
|
||||
// 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 Allocator,typename FunctionObj>
|
||||
void
|
||||
init_a(const reference_wrapper<FunctionObj>& f, function_obj_ref_tag)
|
||||
{
|
||||
init(f,function_obj_ref_tag());
|
||||
}
|
||||
|
||||
template<typename FunctionObj>
|
||||
bool
|
||||
assign_to(const reference_wrapper<FunctionObj>& f,
|
||||
function_buffer& functor, function_obj_ref_tag)
|
||||
{
|
||||
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;
|
||||
if (!boost::detail::function::has_empty_target(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;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
template<typename FunctionObj,typename Allocator>
|
||||
bool
|
||||
@ -639,7 +533,6 @@ namespace boost {
|
||||
}
|
||||
|
||||
public:
|
||||
vtable_base base;
|
||||
invoker_type invoker;
|
||||
};
|
||||
} // end namespace function
|
||||
@ -675,11 +568,6 @@ namespace boost {
|
||||
R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
|
||||
vtable_type;
|
||||
|
||||
vtable_type* get_vtable() const {
|
||||
return reinterpret_cast<vtable_type*>(
|
||||
reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
|
||||
}
|
||||
|
||||
struct clear_type {};
|
||||
|
||||
public:
|
||||
@ -751,14 +639,20 @@ namespace boost {
|
||||
|
||||
~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())
|
||||
boost::throw_exception(bad_function_call());
|
||||
|
||||
return get_vtable()->invoker
|
||||
return static_cast<vtable_type*>(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
|
||||
@ -777,26 +671,24 @@ namespace boost {
|
||||
operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
|
||||
{
|
||||
this->clear();
|
||||
BOOST_TRY {
|
||||
try {
|
||||
this->assign_to(f);
|
||||
} BOOST_CATCH (...) {
|
||||
} catch (...) {
|
||||
vtable = 0;
|
||||
BOOST_RETHROW;
|
||||
throw;
|
||||
}
|
||||
BOOST_CATCH_END
|
||||
return *this;
|
||||
}
|
||||
template<typename Functor,typename Allocator>
|
||||
void assign(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a)
|
||||
{
|
||||
this->clear();
|
||||
BOOST_TRY{
|
||||
try {
|
||||
this->assign_to_a(f,a);
|
||||
} BOOST_CATCH (...) {
|
||||
} catch (...) {
|
||||
vtable = 0;
|
||||
BOOST_RETHROW;
|
||||
throw;
|
||||
}
|
||||
BOOST_CATCH_END
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
@ -821,13 +713,12 @@ namespace boost {
|
||||
return *this;
|
||||
|
||||
this->clear();
|
||||
BOOST_TRY {
|
||||
try {
|
||||
this->assign_to_own(f);
|
||||
} BOOST_CATCH (...) {
|
||||
} catch (...) {
|
||||
vtable = 0;
|
||||
BOOST_RETHROW;
|
||||
throw;
|
||||
}
|
||||
BOOST_CATCH_END
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -846,8 +737,7 @@ namespace boost {
|
||||
void clear()
|
||||
{
|
||||
if (vtable) {
|
||||
if (!this->has_trivial_copy_and_destroy())
|
||||
get_vtable()->clear(this->functor);
|
||||
static_cast<vtable_type*>(vtable)->clear(this->functor);
|
||||
vtable = 0;
|
||||
}
|
||||
}
|
||||
@ -876,79 +766,24 @@ namespace boost {
|
||||
{
|
||||
if (!f.empty()) {
|
||||
this->vtable = f.vtable;
|
||||
if (this->has_trivial_copy_and_destroy())
|
||||
this->functor = f.functor;
|
||||
else
|
||||
get_vtable()->base.manager(f.functor, this->functor,
|
||||
boost::detail::function::clone_functor_tag);
|
||||
f.vtable->manager(f.functor, this->functor,
|
||||
boost::detail::function::clone_functor_tag);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
void assign_to(Functor f)
|
||||
{
|
||||
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>
|
||||
handler_type;
|
||||
|
||||
typedef typename handler_type::invoker_type invoker_type;
|
||||
typedef typename handler_type::manager_type manager_type;
|
||||
|
||||
// Note: it is extremely important that this initialization use
|
||||
// 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 =
|
||||
{ { &manager_type::manage }, &invoker_type::invoke };
|
||||
|
||||
if (stored_vtable.assign_to(f, functor)) {
|
||||
std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
|
||||
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);
|
||||
vtable = reinterpret_cast<detail::function::vtable_base *>(value);
|
||||
} else
|
||||
vtable = 0;
|
||||
static vtable_type stored_vtable(f);
|
||||
if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable;
|
||||
else vtable = 0;
|
||||
}
|
||||
|
||||
template<typename Functor,typename Allocator>
|
||||
void assign_to_a(Functor f,Allocator a)
|
||||
{
|
||||
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_a<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;
|
||||
|
||||
// Note: it is extremely important that this initialization use
|
||||
// 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 =
|
||||
{ { &manager_type::manage }, &invoker_type::invoke };
|
||||
|
||||
if (stored_vtable.assign_to_a(f, functor, a)) {
|
||||
std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
|
||||
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);
|
||||
vtable = reinterpret_cast<detail::function::vtable_base *>(value);
|
||||
} else
|
||||
vtable = 0;
|
||||
static vtable_type stored_vtable(f,a);
|
||||
if (stored_vtable.assign_to_a(f, functor, a)) vtable = &stored_vtable;
|
||||
else vtable = 0;
|
||||
}
|
||||
|
||||
// Moves the value from the specified argument to *this. If the argument
|
||||
@ -959,23 +794,23 @@ namespace boost {
|
||||
if (&f == this)
|
||||
return;
|
||||
|
||||
BOOST_TRY {
|
||||
#if !defined(BOOST_NO_EXCEPTIONS)
|
||||
try {
|
||||
#endif
|
||||
if (!f.empty()) {
|
||||
this->vtable = f.vtable;
|
||||
if (this->has_trivial_copy_and_destroy())
|
||||
this->functor = f.functor;
|
||||
else
|
||||
get_vtable()->base.manager(f.functor, this->functor,
|
||||
boost::detail::function::move_functor_tag);
|
||||
f.vtable = 0;
|
||||
f.vtable->manager(f.functor, this->functor,
|
||||
boost::detail::function::move_functor_tag);
|
||||
f.vtable = 0;
|
||||
#if !defined(BOOST_NO_EXCEPTIONS)
|
||||
} else {
|
||||
clear();
|
||||
}
|
||||
} BOOST_CATCH (...) {
|
||||
} catch (...) {
|
||||
vtable = 0;
|
||||
BOOST_RETHROW;
|
||||
throw;
|
||||
}
|
||||
BOOST_CATCH_END
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
@ -992,6 +827,21 @@ 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
|
||||
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 static_cast<vtable_type*>(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<
|
||||
@ -1114,13 +964,10 @@ public:
|
||||
#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_INVOKER
|
||||
#undef BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
#undef BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
#undef BOOST_FUNCTION_PARMS
|
||||
|
||||
@ -8,7 +8,6 @@
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
project
|
||||
: requirements <toolset>msvc:<asynch-exceptions>on
|
||||
: source-location $(BOOST_ROOT)
|
||||
;
|
||||
|
||||
|
||||
@ -128,10 +128,6 @@ test_main(int, char*[])
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
fv.assign( &do_nothing, std::allocator<int>() );
|
||||
fv.clear();
|
||||
|
||||
function0<void> fv2;
|
||||
fv.assign(&do_nothing, std::allocator<int>() );
|
||||
fv2.assign(fv, std::allocator<int>() );
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -13,8 +13,8 @@
|
||||
#include <string>
|
||||
#include <utility>
|
||||
|
||||
using boost::function;
|
||||
using std::string;
|
||||
using namespace boost;
|
||||
using namespace std;
|
||||
|
||||
int global_int;
|
||||
|
||||
@ -525,7 +525,7 @@ test_zero_args()
|
||||
static void
|
||||
test_one_arg()
|
||||
{
|
||||
std::negate<int> neg;
|
||||
negate<int> neg;
|
||||
|
||||
function<int (int)> f1(neg);
|
||||
BOOST_CHECK(f1(5) == -5);
|
||||
@ -607,12 +607,12 @@ struct add_with_throw_on_copy {
|
||||
|
||||
add_with_throw_on_copy(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw std::runtime_error("But this CAN'T throw");
|
||||
throw runtime_error("But this CAN'T throw");
|
||||
}
|
||||
|
||||
add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw std::runtime_error("But this CAN'T throw");
|
||||
throw runtime_error("But this CAN'T throw");
|
||||
}
|
||||
};
|
||||
|
||||
@ -621,38 +621,14 @@ test_ref()
|
||||
{
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function<int (int, int)> f(boost::ref(atc));
|
||||
boost::function<int (int, int)> f(ref(atc));
|
||||
BOOST_CHECK(f(1, 3) == 4);
|
||||
}
|
||||
catch(std::runtime_error e) {
|
||||
catch(runtime_error e) {
|
||||
BOOST_ERROR("Nonthrowing constructor threw an exception");
|
||||
}
|
||||
}
|
||||
|
||||
static void dummy() {}
|
||||
|
||||
static void test_empty_ref()
|
||||
{
|
||||
boost::function<void()> f1;
|
||||
boost::function<void()> f2(boost::ref(f1));
|
||||
|
||||
try {
|
||||
f2();
|
||||
BOOST_ERROR("Exception didn't throw for reference to empty function.");
|
||||
}
|
||||
catch(std::runtime_error e) {}
|
||||
|
||||
f1 = dummy;
|
||||
|
||||
try {
|
||||
f2();
|
||||
}
|
||||
catch(std::runtime_error e) {
|
||||
BOOST_ERROR("Error calling referenced function.");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void test_exception()
|
||||
{
|
||||
boost::function<int (int, int)> f;
|
||||
@ -698,7 +674,6 @@ int test_main(int, char* [])
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
test_empty_ref();
|
||||
test_exception();
|
||||
test_implicit();
|
||||
test_call();
|
||||
|
||||
@ -15,21 +15,21 @@
|
||||
#include <boost/lambda/bind.hpp>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
using namespace boost::lambda;
|
||||
|
||||
static unsigned
|
||||
func_impl(int arg1, bool arg2, double arg3)
|
||||
{
|
||||
using namespace std;
|
||||
return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
using boost::function;
|
||||
using namespace boost::lambda;
|
||||
|
||||
function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
|
||||
function <unsigned(double)> f2 = boost::lambda::bind(f1, false, _1);
|
||||
function <unsigned()> f3 = boost::lambda::bind(f2, 4.0);
|
||||
function <unsigned(double)> f2 = bind(f1, false, _1);
|
||||
function <unsigned()> f3 = bind(f2, 4.0);
|
||||
|
||||
f3();
|
||||
|
||||
|
||||
Reference in New Issue
Block a user