Files

1204 lines
43 KiB
C++

// Boost.Function library
// Copyright Douglas Gregor 2001-2006
// Copyright Emil Dotchevski 2007
// Use, modification and distribution is subject to the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// For more information, see http://www.boost.org
// Note: this header is a header template and must NOT have multiple-inclusion
// protection.
#include <ActivBoost/function/detail/prologue.hpp>
#include <ActivBoost/core/no_exceptions_support.hpp>
#if defined(ACTIV_BOOST_MSVC)
# pragma warning( push )
# pragma warning( disable : 4127 ) // "conditional expression is constant"
#endif
#define ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS ACTIV_BOOST_PP_ENUM_PARAMS(ACTIV_BOOST_FUNCTION_NUM_ARGS, typename T)
#define ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS ACTIV_BOOST_PP_ENUM_PARAMS(ACTIV_BOOST_FUNCTION_NUM_ARGS, T)
#define ACTIV_BOOST_FUNCTION_PARM(J,I,D) ACTIV_BOOST_PP_CAT(T,I) ACTIV_BOOST_PP_CAT(a,I)
#define ACTIV_BOOST_FUNCTION_PARMS ACTIV_BOOST_PP_ENUM(ACTIV_BOOST_FUNCTION_NUM_ARGS,ACTIV_BOOST_FUNCTION_PARM,ACTIV_BOOST_PP_EMPTY)
#ifdef ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES
# define ACTIV_BOOST_FUNCTION_ARGS ACTIV_BOOST_PP_ENUM_PARAMS(ACTIV_BOOST_FUNCTION_NUM_ARGS, a)
#else
# define ACTIV_BOOST_FUNCTION_ARG(J,I,D) static_cast<ACTIV_BOOST_PP_CAT(T,I)&&>(ACTIV_BOOST_PP_CAT(a,I))
# define ACTIV_BOOST_FUNCTION_ARGS ACTIV_BOOST_PP_ENUM(ACTIV_BOOST_FUNCTION_NUM_ARGS,ACTIV_BOOST_FUNCTION_ARG,ACTIV_BOOST_PP_EMPTY)
#endif
#define ACTIV_BOOST_FUNCTION_ARG_TYPE(J,I,D) \
typedef ACTIV_BOOST_PP_CAT(T,I) ACTIV_BOOST_PP_CAT(ACTIV_BOOST_PP_CAT(arg, ACTIV_BOOST_PP_INC(I)),_type);
#define ACTIV_BOOST_FUNCTION_ARG_TYPES ACTIV_BOOST_PP_REPEAT(ACTIV_BOOST_FUNCTION_NUM_ARGS,ACTIV_BOOST_FUNCTION_ARG_TYPE,ACTIV_BOOST_PP_EMPTY)
// Comma if nonzero number of arguments
#if ACTIV_BOOST_FUNCTION_NUM_ARGS == 0
# define ACTIV_BOOST_FUNCTION_COMMA
#else
# define ACTIV_BOOST_FUNCTION_COMMA ,
#endif // ACTIV_BOOST_FUNCTION_NUM_ARGS > 0
// Class names used in this version of the code
#define ACTIV_BOOST_FUNCTION_FUNCTION ACTIV_BOOST_JOIN(function,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_FUNCTION_INVOKER \
ACTIV_BOOST_JOIN(function_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_VOID_FUNCTION_INVOKER \
ACTIV_BOOST_JOIN(void_function_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_FUNCTION_OBJ_INVOKER \
ACTIV_BOOST_JOIN(function_obj_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \
ACTIV_BOOST_JOIN(void_function_obj_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_FUNCTION_REF_INVOKER \
ACTIV_BOOST_JOIN(function_ref_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
ACTIV_BOOST_JOIN(void_function_ref_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_MEMBER_INVOKER \
ACTIV_BOOST_JOIN(function_mem_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_VOID_MEMBER_INVOKER \
ACTIV_BOOST_JOIN(function_void_mem_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_GET_FUNCTION_INVOKER \
ACTIV_BOOST_JOIN(get_function_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
ACTIV_BOOST_JOIN(get_function_obj_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
ACTIV_BOOST_JOIN(get_function_ref_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_GET_MEMBER_INVOKER \
ACTIV_BOOST_JOIN(get_member_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_GET_INVOKER \
ACTIV_BOOST_JOIN(get_invoker,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#define ACTIV_BOOST_FUNCTION_VTABLE ACTIV_BOOST_JOIN(basic_vtable,ACTIV_BOOST_FUNCTION_NUM_ARGS)
#ifndef ACTIV_BOOST_NO_VOID_RETURNS
# define ACTIV_BOOST_FUNCTION_VOID_RETURN_TYPE void
# define ACTIV_BOOST_FUNCTION_RETURN(X) X
#else
# define ACTIV_BOOST_FUNCTION_VOID_RETURN_TYPE Boost::detail::function::unusable
# define ACTIV_BOOST_FUNCTION_RETURN(X) X; return ACTIV_BOOST_FUNCTION_VOID_RETURN_TYPE ()
#endif
namespace Boost {
namespace detail {
namespace function {
template<
typename FunctionPtr,
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
struct ACTIV_BOOST_FUNCTION_FUNCTION_INVOKER
{
static R invoke(function_buffer& function_ptr ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_PARMS)
{
FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
return f(ACTIV_BOOST_FUNCTION_ARGS);
}
};
template<
typename FunctionPtr,
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
struct ACTIV_BOOST_FUNCTION_VOID_FUNCTION_INVOKER
{
static ACTIV_BOOST_FUNCTION_VOID_RETURN_TYPE
invoke(function_buffer& function_ptr ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_PARMS)
{
FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
ACTIV_BOOST_FUNCTION_RETURN(f(ACTIV_BOOST_FUNCTION_ARGS));
}
};
template<
typename FunctionObj,
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
struct ACTIV_BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
{
static R invoke(function_buffer& function_obj_ptr ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_PARMS)
{
FunctionObj* f;
if (function_allows_small_object_optimization<FunctionObj>::value)
f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
else
f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
return (*f)(ACTIV_BOOST_FUNCTION_ARGS);
}
};
template<
typename FunctionObj,
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
struct ACTIV_BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
{
static ACTIV_BOOST_FUNCTION_VOID_RETURN_TYPE
invoke(function_buffer& function_obj_ptr ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_PARMS)
{
FunctionObj* f;
if (function_allows_small_object_optimization<FunctionObj>::value)
f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
else
f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
ACTIV_BOOST_FUNCTION_RETURN((*f)(ACTIV_BOOST_FUNCTION_ARGS));
}
};
template<
typename FunctionObj,
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
struct ACTIV_BOOST_FUNCTION_FUNCTION_REF_INVOKER
{
static R invoke(function_buffer& function_obj_ptr ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_PARMS)
{
FunctionObj* f =
reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
return (*f)(ACTIV_BOOST_FUNCTION_ARGS);
}
};
template<
typename FunctionObj,
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
struct ACTIV_BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
{
static ACTIV_BOOST_FUNCTION_VOID_RETURN_TYPE
invoke(function_buffer& function_obj_ptr ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_PARMS)
{
FunctionObj* f =
reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
ACTIV_BOOST_FUNCTION_RETURN((*f)(ACTIV_BOOST_FUNCTION_ARGS));
}
};
#if ACTIV_BOOST_FUNCTION_NUM_ARGS > 0
/* Handle invocation of member pointers. */
template<
typename MemberPtr,
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
struct ACTIV_BOOST_FUNCTION_MEMBER_INVOKER
{
static R invoke(function_buffer& function_obj_ptr ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_PARMS)
{
MemberPtr* f =
reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
return Boost::mem_fn(*f)(ACTIV_BOOST_FUNCTION_ARGS);
}
};
template<
typename MemberPtr,
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
struct ACTIV_BOOST_FUNCTION_VOID_MEMBER_INVOKER
{
static ACTIV_BOOST_FUNCTION_VOID_RETURN_TYPE
invoke(function_buffer& function_obj_ptr ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_PARMS)
{
MemberPtr* f =
reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
ACTIV_BOOST_FUNCTION_RETURN(Boost::mem_fn(*f)(ACTIV_BOOST_FUNCTION_ARGS));
}
};
#endif
template<
typename FunctionPtr,
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
struct ACTIV_BOOST_FUNCTION_GET_FUNCTION_INVOKER
{
typedef typename conditional<(is_void<R>::value),
ACTIV_BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
FunctionPtr,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>,
ACTIV_BOOST_FUNCTION_FUNCTION_INVOKER<
FunctionPtr,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>
>::type type;
};
template<
typename FunctionObj,
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
struct ACTIV_BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
{
typedef typename conditional<(is_void<R>::value),
ACTIV_BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
FunctionObj,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>,
ACTIV_BOOST_FUNCTION_FUNCTION_OBJ_INVOKER<
FunctionObj,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>
>::type type;
};
template<
typename FunctionObj,
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
struct ACTIV_BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
{
typedef typename conditional<(is_void<R>::value),
ACTIV_BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
FunctionObj,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>,
ACTIV_BOOST_FUNCTION_FUNCTION_REF_INVOKER<
FunctionObj,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>
>::type type;
};
#if ACTIV_BOOST_FUNCTION_NUM_ARGS > 0
/* Retrieve the appropriate invoker for a member pointer. */
template<
typename MemberPtr,
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
struct ACTIV_BOOST_FUNCTION_GET_MEMBER_INVOKER
{
typedef typename conditional<(is_void<R>::value),
ACTIV_BOOST_FUNCTION_VOID_MEMBER_INVOKER<
MemberPtr,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>,
ACTIV_BOOST_FUNCTION_MEMBER_INVOKER<
MemberPtr,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_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 ACTIV_BOOST_FUNCTION_GET_INVOKER { };
/* Retrieve the invoker for a function pointer. */
template<>
struct ACTIV_BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
{
template<typename FunctionPtr,
typename R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
struct apply
{
typedef typename ACTIV_BOOST_FUNCTION_GET_FUNCTION_INVOKER<
FunctionPtr,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>::type
invoker_type;
typedef functor_manager<FunctionPtr> manager_type;
};
template<typename FunctionPtr, typename Allocator,
typename R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
struct apply_a
{
typedef typename ACTIV_BOOST_FUNCTION_GET_FUNCTION_INVOKER<
FunctionPtr,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>::type
invoker_type;
typedef functor_manager<FunctionPtr> manager_type;
};
};
#if ACTIV_BOOST_FUNCTION_NUM_ARGS > 0
/* Retrieve the invoker for a member pointer. */
template<>
struct ACTIV_BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
{
template<typename MemberPtr,
typename R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
struct apply
{
typedef typename ACTIV_BOOST_FUNCTION_GET_MEMBER_INVOKER<
MemberPtr,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>::type
invoker_type;
typedef functor_manager<MemberPtr> manager_type;
};
template<typename MemberPtr, typename Allocator,
typename R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
struct apply_a
{
typedef typename ACTIV_BOOST_FUNCTION_GET_MEMBER_INVOKER<
MemberPtr,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>::type
invoker_type;
typedef functor_manager<MemberPtr> manager_type;
};
};
#endif
/* Retrieve the invoker for a function object. */
template<>
struct ACTIV_BOOST_FUNCTION_GET_INVOKER<function_obj_tag>
{
template<typename FunctionObj,
typename R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
struct apply
{
typedef typename ACTIV_BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
FunctionObj,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>::type
invoker_type;
typedef functor_manager<FunctionObj> manager_type;
};
template<typename FunctionObj, typename Allocator,
typename R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
struct apply_a
{
typedef typename ACTIV_BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
FunctionObj,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_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 ACTIV_BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
{
template<typename RefWrapper,
typename R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
struct apply
{
typedef typename ACTIV_BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
typename RefWrapper::type,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>::type
invoker_type;
typedef reference_manager<typename RefWrapper::type> manager_type;
};
template<typename RefWrapper, typename Allocator,
typename R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
struct apply_a
{
typedef typename ACTIV_BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
typename RefWrapper::type,
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_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.
*/
template<typename R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
struct ACTIV_BOOST_FUNCTION_VTABLE
{
#ifndef ACTIV_BOOST_NO_VOID_RETURNS
typedef R result_type;
#else
typedef typename function_return_type<R>::type result_type;
#endif // ACTIV_BOOST_NO_VOID_RETURNS
typedef result_type (*invoker_type)(function_buffer&
ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS);
template<typename F>
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) const
{
typedef typename get_function_tag<F>::type tag;
return assign_to_a(f, functor, a, tag());
}
void clear(function_buffer& functor) const
{
if (base.manager)
base.manager(functor, functor, destroy_functor_tag);
}
private:
// Function pointers
template<typename FunctionPtr>
bool
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.members.func_ptr = reinterpret_cast<void (*)()>(f);
return true;
} else {
return false;
}
}
template<typename FunctionPtr,typename Allocator>
bool
assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
{
return assign_to(f,functor,function_ptr_tag());
}
// Member pointers
#if ACTIV_BOOST_FUNCTION_NUM_ARGS > 0
template<typename MemberPtr>
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(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) 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(Boost::mem_fn(f), functor, a);
return true;
} else {
return false;
}
}
#endif // ACTIV_BOOST_FUNCTION_NUM_ARGS > 0
// Function objects
// Assign to a function object using the small object optimization
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, true_type) const
{
new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
}
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
{
assign_functor(f,functor,true_type());
}
// Assign to a function object allocated on the heap.
template<typename FunctionObj>
void
assign_functor(FunctionObj f, function_buffer& functor, false_type) const
{
functor.members.obj_ptr = new FunctionObj(f);
}
template<typename FunctionObj,typename Allocator>
void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
{
typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
#if defined(ACTIV_BOOST_NO_CXX11_ALLOCATOR)
typedef typename Allocator::template rebind<functor_wrapper_type>::other
wrapper_allocator_type;
typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
#else
using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
#endif
wrapper_allocator_type wrapper_allocator(a);
wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
#if defined(ACTIV_BOOST_NO_CXX11_ALLOCATOR)
wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
#else
std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
#endif
functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
functor.members.obj_ptr = new_f;
}
template<typename FunctionObj>
bool
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,
integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
return true;
} else {
return false;
}
}
template<typename FunctionObj,typename Allocator>
bool
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,
integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
return true;
} else {
return false;
}
}
// Reference to a function object
template<typename FunctionObj>
bool
assign_to(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, function_obj_ref_tag) const
{
functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
return true;
}
template<typename FunctionObj,typename Allocator>
bool
assign_to_a(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, Allocator, function_obj_ref_tag) const
{
return assign_to(f,functor,function_obj_ref_tag());
}
public:
vtable_base base;
invoker_type invoker;
};
} // end namespace function
} // end namespace detail
template<
typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
>
class ACTIV_BOOST_FUNCTION_FUNCTION : public function_base
{
public:
#ifndef ACTIV_BOOST_NO_VOID_RETURNS
typedef R result_type;
#else
typedef typename Boost::detail::function::function_return_type<R>::type
result_type;
#endif // ACTIV_BOOST_NO_VOID_RETURNS
private:
typedef Boost::detail::function::ACTIV_BOOST_FUNCTION_VTABLE<
R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS>
vtable_type;
vtable_type* get_vtable() const {
return reinterpret_cast<vtable_type*>(
reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
}
struct clear_type {};
public:
ACTIV_BOOST_STATIC_CONSTANT(int, args = ACTIV_BOOST_FUNCTION_NUM_ARGS);
// add signature for Boost::lambda
template<typename Args>
struct sig
{
typedef result_type type;
};
#if ACTIV_BOOST_FUNCTION_NUM_ARGS == 1
typedef T0 argument_type;
#elif ACTIV_BOOST_FUNCTION_NUM_ARGS == 2
typedef T0 first_argument_type;
typedef T1 second_argument_type;
#endif
ACTIV_BOOST_STATIC_CONSTANT(int, arity = ACTIV_BOOST_FUNCTION_NUM_ARGS);
ACTIV_BOOST_FUNCTION_ARG_TYPES
typedef ACTIV_BOOST_FUNCTION_FUNCTION self_type;
ACTIV_BOOST_DEFAULTED_FUNCTION(ACTIV_BOOST_FUNCTION_FUNCTION(), : function_base() {})
// MSVC chokes if the following two constructors are collapsed into
// one with a default parameter.
template<typename Functor>
ACTIV_BOOST_FUNCTION_FUNCTION(Functor ACTIV_BOOST_FUNCTION_TARGET_FIX(const &) f
#ifndef ACTIV_BOOST_NO_SFINAE
,typename Boost::enable_if_<
!(is_integral<Functor>::value),
int>::type = 0
#endif // ACTIV_BOOST_NO_SFINAE
) :
function_base()
{
this->assign_to(f);
}
template<typename Functor,typename Allocator>
ACTIV_BOOST_FUNCTION_FUNCTION(Functor ACTIV_BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
#ifndef ACTIV_BOOST_NO_SFINAE
,typename Boost::enable_if_<
!(is_integral<Functor>::value),
int>::type = 0
#endif // ACTIV_BOOST_NO_SFINAE
) :
function_base()
{
this->assign_to_a(f,a);
}
#ifndef ACTIV_BOOST_NO_SFINAE
ACTIV_BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
#else
ACTIV_BOOST_FUNCTION_FUNCTION(int zero) : function_base()
{
ACTIV_BOOST_ASSERT(zero == 0);
}
#endif
ACTIV_BOOST_FUNCTION_FUNCTION(const ACTIV_BOOST_FUNCTION_FUNCTION& f) : function_base()
{
this->assign_to_own(f);
}
#ifndef ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES
ACTIV_BOOST_FUNCTION_FUNCTION(ACTIV_BOOST_FUNCTION_FUNCTION&& f) : function_base()
{
this->move_assign(f);
}
#endif
~ACTIV_BOOST_FUNCTION_FUNCTION() { clear(); }
result_type operator()(ACTIV_BOOST_FUNCTION_PARMS) const
{
if (this->empty())
Boost::throw_exception(bad_function_call());
return get_vtable()->invoker
(this->functor ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_ARGS);
}
// The distinction between when to use ACTIV_BOOST_FUNCTION_FUNCTION and
// when to use self_type is obnoxious. MSVC cannot handle self_type as
// the return type of these assignment operators, but Borland C++ cannot
// handle ACTIV_BOOST_FUNCTION_FUNCTION as the type of the temporary to
// construct.
template<typename Functor>
#ifndef ACTIV_BOOST_NO_SFINAE
typename Boost::enable_if_<
!(is_integral<Functor>::value),
ACTIV_BOOST_FUNCTION_FUNCTION&>::type
#else
ACTIV_BOOST_FUNCTION_FUNCTION&
#endif
operator=(Functor ACTIV_BOOST_FUNCTION_TARGET_FIX(const &) f)
{
this->clear();
ACTIV_BOOST_TRY {
this->assign_to(f);
} ACTIV_BOOST_CATCH (...) {
vtable = 0;
ACTIV_BOOST_RETHROW;
}
ACTIV_BOOST_CATCH_END
return *this;
}
template<typename Functor,typename Allocator>
void assign(Functor ACTIV_BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a)
{
this->clear();
ACTIV_BOOST_TRY{
this->assign_to_a(f,a);
} ACTIV_BOOST_CATCH (...) {
vtable = 0;
ACTIV_BOOST_RETHROW;
}
ACTIV_BOOST_CATCH_END
}
#ifndef ACTIV_BOOST_NO_SFINAE
ACTIV_BOOST_FUNCTION_FUNCTION& operator=(clear_type*)
{
this->clear();
return *this;
}
#else
ACTIV_BOOST_FUNCTION_FUNCTION& operator=(int zero)
{
ACTIV_BOOST_ASSERT(zero == 0);
this->clear();
return *this;
}
#endif
// Assignment from another ACTIV_BOOST_FUNCTION_FUNCTION
ACTIV_BOOST_FUNCTION_FUNCTION& operator=(const ACTIV_BOOST_FUNCTION_FUNCTION& f)
{
if (&f == this)
return *this;
this->clear();
ACTIV_BOOST_TRY {
this->assign_to_own(f);
} ACTIV_BOOST_CATCH (...) {
vtable = 0;
ACTIV_BOOST_RETHROW;
}
ACTIV_BOOST_CATCH_END
return *this;
}
#ifndef ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES
// Move assignment from another ACTIV_BOOST_FUNCTION_FUNCTION
ACTIV_BOOST_FUNCTION_FUNCTION& operator=(ACTIV_BOOST_FUNCTION_FUNCTION&& f)
{
if (&f == this)
return *this;
this->clear();
ACTIV_BOOST_TRY {
this->move_assign(f);
} ACTIV_BOOST_CATCH (...) {
vtable = 0;
ACTIV_BOOST_RETHROW;
}
ACTIV_BOOST_CATCH_END
return *this;
}
#endif
void swap(ACTIV_BOOST_FUNCTION_FUNCTION& other)
{
if (&other == this)
return;
ACTIV_BOOST_FUNCTION_FUNCTION tmp;
tmp.move_assign(*this);
this->move_assign(other);
other.move_assign(tmp);
}
// Clear out a target, if there is one
void clear()
{
if (vtable) {
if (!this->has_trivial_copy_and_destroy())
get_vtable()->clear(this->functor);
vtable = 0;
}
}
#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined ACTIV_BOOST_NO_COMPILER_CONFIG)
// Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it
operator bool () const { return !this->empty(); }
#else
private:
struct dummy {
void nonnull() {}
};
typedef void (dummy::*safe_bool)();
public:
operator safe_bool () const
{ return (this->empty())? 0 : &dummy::nonnull; }
bool operator!() const
{ return this->empty(); }
#endif
private:
void assign_to_own(const ACTIV_BOOST_FUNCTION_FUNCTION& f)
{
if (!f.empty()) {
this->vtable = f.vtable;
if (this->has_trivial_copy_and_destroy()) {
// Don't operate on storage directly since union type doesn't relax
// strict aliasing rules, despite of having member char type.
# if defined(ACTIV_BOOST_GCC) && (ACTIV_BOOST_GCC >= 40700)
# pragma GCC diagnostic push
// This warning is technically correct, but we don't want to pay the price for initializing
// just to silence a warning: https://github.com/boostorg/function/issues/27
# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
# endif
std::memcpy(this->functor.data, f.functor.data, sizeof(Boost::detail::function::function_buffer));
# if defined(ACTIV_BOOST_GCC) && (ACTIV_BOOST_GCC >= 40700)
# pragma GCC diagnostic pop
# endif
} else
get_vtable()->base.manager(f.functor, this->functor,
Boost::detail::function::clone_functor_tag);
}
}
template<typename Functor>
void assign_to(Functor f)
{
using Boost::detail::function::vtable_base;
typedef typename Boost::detail::function::get_function_tag<Functor>::type tag;
typedef Boost::detail::function::ACTIV_BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
typedef typename get_invoker::
template apply<Functor, R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_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 const 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);
// coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
if (Boost::has_trivial_copy_constructor<Functor>::value &&
Boost::has_trivial_destructor<Functor>::value &&
Boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<Boost::detail::function::vtable_base *>(value);
} else
vtable = 0;
}
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
{
using Boost::detail::function::vtable_base;
typedef typename Boost::detail::function::get_function_tag<Functor>::type tag;
typedef Boost::detail::function::ACTIV_BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
typedef typename get_invoker::
template apply_a<Functor, Allocator, R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_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 const 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);
// coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
if (Boost::has_trivial_copy_constructor<Functor>::value &&
Boost::has_trivial_destructor<Functor>::value &&
Boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<Boost::detail::function::vtable_base *>(value);
} else
vtable = 0;
}
// Moves the value from the specified argument to *this. If the argument
// has its function object allocated on the heap, move_assign will pass
// its buffer to *this, and set the argument's buffer pointer to NULL.
void move_assign(ACTIV_BOOST_FUNCTION_FUNCTION& f)
{
if (&f == this)
return;
ACTIV_BOOST_TRY {
if (!f.empty()) {
this->vtable = f.vtable;
if (this->has_trivial_copy_and_destroy()) {
// Don't operate on storage directly since union type doesn't relax
// strict aliasing rules, despite of having member char type.
# if defined(ACTIV_BOOST_GCC) && (ACTIV_BOOST_GCC >= 40700)
# pragma GCC diagnostic push
// This warning is technically correct, but we don't want to pay the price for initializing
// just to silence a warning: https://github.com/boostorg/function/issues/27
# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
# endif
std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
# if defined(ACTIV_BOOST_GCC) && (ACTIV_BOOST_GCC >= 40700)
# pragma GCC diagnostic pop
# endif
} else
get_vtable()->base.manager(f.functor, this->functor,
Boost::detail::function::move_functor_tag);
f.vtable = 0;
} else {
clear();
}
} ACTIV_BOOST_CATCH (...) {
vtable = 0;
ACTIV_BOOST_RETHROW;
}
ACTIV_BOOST_CATCH_END
}
};
template<typename R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
inline void swap(ACTIV_BOOST_FUNCTION_FUNCTION<
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>& f1,
ACTIV_BOOST_FUNCTION_FUNCTION<
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
>& f2)
{
f1.swap(f2);
}
// Poison comparisons between Boost::function objects of the same type.
template<typename R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
void operator==(const ACTIV_BOOST_FUNCTION_FUNCTION<
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS>&,
const ACTIV_BOOST_FUNCTION_FUNCTION<
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS>&);
template<typename R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
void operator!=(const ACTIV_BOOST_FUNCTION_FUNCTION<
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS>&,
const ACTIV_BOOST_FUNCTION_FUNCTION<
R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS>& );
#if !defined(ACTIV_BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
#if ACTIV_BOOST_FUNCTION_NUM_ARGS == 0
#define ACTIV_BOOST_FUNCTION_PARTIAL_SPEC R (void)
#else
#define ACTIV_BOOST_FUNCTION_PARTIAL_SPEC R (ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS)
#endif
template<typename R ACTIV_BOOST_FUNCTION_COMMA
ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS>
class function<ACTIV_BOOST_FUNCTION_PARTIAL_SPEC>
: public ACTIV_BOOST_FUNCTION_FUNCTION<R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS>
{
typedef ACTIV_BOOST_FUNCTION_FUNCTION<R ACTIV_BOOST_FUNCTION_COMMA ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS> base_type;
typedef function self_type;
struct clear_type {};
public:
ACTIV_BOOST_DEFAULTED_FUNCTION(function(), : base_type() {})
template<typename Functor>
function(Functor f
#ifndef ACTIV_BOOST_NO_SFINAE
,typename Boost::enable_if_<
!(is_integral<Functor>::value),
int>::type = 0
#endif
) :
base_type(f)
{
}
template<typename Functor,typename Allocator>
function(Functor f, Allocator a
#ifndef ACTIV_BOOST_NO_SFINAE
,typename Boost::enable_if_<
!(is_integral<Functor>::value),
int>::type = 0
#endif
) :
base_type(f,a)
{
}
#ifndef ACTIV_BOOST_NO_SFINAE
function(clear_type*) : base_type() {}
#endif
function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
#ifndef ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES
// Move constructors
function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
#endif
self_type& operator=(const self_type& f)
{
self_type(f).swap(*this);
return *this;
}
#ifndef ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES
self_type& operator=(self_type&& f)
{
self_type(static_cast<self_type&&>(f)).swap(*this);
return *this;
}
#endif
template<typename Functor>
#ifndef ACTIV_BOOST_NO_SFINAE
typename Boost::enable_if_<
!(is_integral<Functor>::value),
self_type&>::type
#else
self_type&
#endif
operator=(Functor f)
{
self_type(f).swap(*this);
return *this;
}
#ifndef ACTIV_BOOST_NO_SFINAE
self_type& operator=(clear_type*)
{
this->clear();
return *this;
}
#endif
self_type& operator=(const base_type& f)
{
self_type(f).swap(*this);
return *this;
}
#ifndef ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES
self_type& operator=(base_type&& f)
{
self_type(static_cast<base_type&&>(f)).swap(*this);
return *this;
}
#endif
};
#undef ACTIV_BOOST_FUNCTION_PARTIAL_SPEC
#endif // have partial specialization
} // end namespace Boost
// Cleanup after ourselves...
#undef ACTIV_BOOST_FUNCTION_VTABLE
#undef ACTIV_BOOST_FUNCTION_COMMA
#undef ACTIV_BOOST_FUNCTION_FUNCTION
#undef ACTIV_BOOST_FUNCTION_FUNCTION_INVOKER
#undef ACTIV_BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef ACTIV_BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
#undef ACTIV_BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef ACTIV_BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef ACTIV_BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
#undef ACTIV_BOOST_FUNCTION_MEMBER_INVOKER
#undef ACTIV_BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef ACTIV_BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef ACTIV_BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef ACTIV_BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
#undef ACTIV_BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef ACTIV_BOOST_FUNCTION_GET_INVOKER
#undef ACTIV_BOOST_FUNCTION_TEMPLATE_PARMS
#undef ACTIV_BOOST_FUNCTION_TEMPLATE_ARGS
#undef ACTIV_BOOST_FUNCTION_PARMS
#undef ACTIV_BOOST_FUNCTION_PARM
#ifdef ACTIV_BOOST_FUNCTION_ARG
# undef ACTIV_BOOST_FUNCTION_ARG
#endif
#undef ACTIV_BOOST_FUNCTION_ARGS
#undef ACTIV_BOOST_FUNCTION_ARG_TYPE
#undef ACTIV_BOOST_FUNCTION_ARG_TYPES
#undef ACTIV_BOOST_FUNCTION_VOID_RETURN_TYPE
#undef ACTIV_BOOST_FUNCTION_RETURN
#if defined(ACTIV_BOOST_MSVC)
# pragma warning( pop )
#endif