forked from boostorg/function
8026bc49d7
https://svn.boost.org/svn/boost/trunk ................ r43810 | eric_niebler | 2008-03-23 14:51:40 -0700 (Sun, 23 Mar 2008) | 1 line mark up new foreach tests ................ r43823 | fmhess | 2008-03-24 08:07:00 -0700 (Mon, 24 Mar 2008) | 3 lines Fixed compile error with new enable_shared_from_this code, reported by Tim Blechmann ................ r43825 | ramey | 2008-03-24 08:46:09 -0700 (Mon, 24 Mar 2008) | 1 line removed EXIT_SUCCESS ................ r43826 | ramey | 2008-03-24 08:46:43 -0700 (Mon, 24 Mar 2008) | 1 line fixed minor typo ................ r43829 | pdimov | 2008-03-24 09:00:28 -0700 (Mon, 24 Mar 2008) | 1 line New enable_shared_from_this tests, fix. ................ r43838 | danieljames | 2008-03-24 10:03:15 -0700 (Mon, 24 Mar 2008) | 12 lines Merge new changes to unordered & hash. - Unordered tests can run lightweight test or Boost.Test (at least theoretically). - Workaround Open BSD's incorrect numeric_limits. - Move the hash extensions in their own file. - Various small improvements to the unordered docs. - Fix some unordered examples. Merged revisions 43117-43837 via svnmerge from https://svn.boost.org/svn/boost/branches/unordered/trunk ................ r43845 | dave | 2008-03-24 11:27:22 -0700 (Mon, 24 Mar 2008) | 1 line Work around vc9 bugs ................ r43847 | anthonyw | 2008-03-24 14:44:36 -0700 (Mon, 24 Mar 2008) | 1 line removed forward declaration for undefined type exclusive_lock ................ r43852 | hkaiser | 2008-03-25 06:40:53 -0700 (Tue, 25 Mar 2008) | 1 line Wave: Removed an assertion causing compilation problems on certain platforms. ................ r43856 | pdimov | 2008-03-25 08:46:40 -0700 (Tue, 25 Mar 2008) | 1 line _internal_accept_owner now checks if _owned isn't already true. ................ r43861 | dave | 2008-03-25 13:47:38 -0700 (Tue, 25 Mar 2008) | 2 lines Work around intel-10.0-win compiler bug ................ r43864 | dave | 2008-03-25 15:28:59 -0700 (Tue, 25 Mar 2008) | 2 lines Account for intel 10.x compiler bug ................ r43865 | dave | 2008-03-25 16:06:50 -0700 (Tue, 25 Mar 2008) | 2 lines Work around intel-win-10.0 preprocessor bug ................ r43866 | danieljames | 2008-03-26 02:10:29 -0700 (Wed, 26 Mar 2008) | 3 lines Boost.Thread's documentation no longer has a build section - so just link to the library's documentation like we do for other libraries. ................ r43867 | bemandawes | 2008-03-26 08:59:52 -0700 (Wed, 26 Mar 2008) | 1 line Initial commit ................ r43873 | pdimov | 2008-03-26 11:34:29 -0700 (Wed, 26 Mar 2008) | 1 line Added "Throws: nothing" to get_deleter. ................ r43875 | bemandawes | 2008-03-26 14:26:55 -0700 (Wed, 26 Mar 2008) | 1 line Initial commit ................ r43876 | danieljames | 2008-03-26 22:49:45 -0700 (Wed, 26 Mar 2008) | 2 lines Update the thread links in the generated getting started documentation. ................ r43879 | chris_kohlhoff | 2008-03-27 07:18:07 -0700 (Thu, 27 Mar 2008) | 3 lines Fix double-free error that occurs when an exception is thrown from a handler that has been dispatched (i.e. not posted) through a strand. ................ r43880 | ramey | 2008-03-27 08:53:37 -0700 (Thu, 27 Mar 2008) | 1 line removed suppression of builds for certain platforms with shared libraries ................ r43882 | ramey | 2008-03-27 10:11:23 -0700 (Thu, 27 Mar 2008) | 1 line tweaks to sneak past PGI compiler error message ................ r43883 | ramey | 2008-03-27 10:12:22 -0700 (Thu, 27 Mar 2008) | 1 line added test to check warnings on type trait ................ r43884 | dgregor | 2008-03-27 12:44:37 -0700 (Thu, 27 Mar 2008) | 1 line Change Boost.Function allocator behavior, from Emil Dotchevski ................ r43887 | pdimov | 2008-03-27 15:13:55 -0700 (Thu, 27 Mar 2008) | 1 line Silence unused parameter warning. ................ r43888 | pdimov | 2008-03-27 15:20:11 -0700 (Thu, 27 Mar 2008) | 1 line detail::yield(k) added. ................ r43895 | danieljames | 2008-03-27 16:38:01 -0700 (Thu, 27 Mar 2008) | 25 lines Merged revisions 43838-43894 via svnmerge from https://svn.boost.org/svn/boost/branches/unordered/trunk ........ r43840 | danieljames | 2008-03-24 17:25:07 +0000 (Mon, 24 Mar 2008) | 1 line Fix a g++ warning. ........ r43844 | danieljames | 2008-03-24 17:56:28 +0000 (Mon, 24 Mar 2008) | 1 line It's a new-ish year. ........ r43885 | danieljames | 2008-03-27 20:36:10 +0000 (Thu, 27 Mar 2008) | 1 line The release script doesn't need to copy images and css - because that's now done in the jamfiles. Also tweak the shell script a tad bit. ........ r43890 | danieljames | 2008-03-27 23:01:40 +0000 (Thu, 27 Mar 2008) | 1 line Starting to add a docbook bibliography. ........ r43894 | danieljames | 2008-03-27 23:24:18 +0000 (Thu, 27 Mar 2008) | 1 line Redeclare 'data' in iterator_base to help compilers which have trouble with accessing the nested typedef. ........ ................ r43900 | noel_belcourt | 2008-03-27 19:10:04 -0700 (Thu, 27 Mar 2008) | 4 lines Fix address-model support for 32/64 bit code generation. Replaced -mcmodel with -m32 / -m64. ................ r43901 | bemandawes | 2008-03-27 19:11:13 -0700 (Thu, 27 Mar 2008) | 1 line Remove per email from Dave ................ r43906 | eric_niebler | 2008-03-27 23:10:55 -0700 (Thu, 27 Mar 2008) | 1 line proto support for BOOST_PROTO_MAX_FUNCTION_CALL_ARITY ................ [SVN r43910]
958 lines
30 KiB
C++
958 lines
30 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 <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)
|
|
|
|
#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
|
|
|
|
#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
|
|
|
|
#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
|
|
|
|
#define BOOST_FUNCTION_ARG_TYPE(J,I,D) \
|
|
typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
|
|
|
|
#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
|
|
|
|
// Comma if nonzero number of arguments
|
|
#if BOOST_FUNCTION_NUM_ARGS == 0
|
|
# define BOOST_FUNCTION_COMMA
|
|
#else
|
|
# define BOOST_FUNCTION_COMMA ,
|
|
#endif // BOOST_FUNCTION_NUM_ARGS > 0
|
|
|
|
// Class names used in this version of the code
|
|
#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
|
|
#define BOOST_FUNCTION_FUNCTION_INVOKER \
|
|
BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
|
|
#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER \
|
|
BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
|
|
#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER \
|
|
BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
|
#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \
|
|
BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
|
#define BOOST_FUNCTION_FUNCTION_REF_INVOKER \
|
|
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_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_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
|
|
|
|
#ifndef BOOST_NO_VOID_RETURNS
|
|
# define BOOST_FUNCTION_VOID_RETURN_TYPE void
|
|
# define BOOST_FUNCTION_RETURN(X) X
|
|
#else
|
|
# define BOOST_FUNCTION_VOID_RETURN_TYPE boost::detail::function::unusable
|
|
# define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()
|
|
#endif
|
|
|
|
namespace boost {
|
|
namespace detail {
|
|
namespace function {
|
|
template<
|
|
typename FunctionPtr,
|
|
typename R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
|
>
|
|
struct BOOST_FUNCTION_FUNCTION_INVOKER
|
|
{
|
|
static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_PARMS)
|
|
{
|
|
FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
|
|
return f(BOOST_FUNCTION_ARGS);
|
|
}
|
|
};
|
|
|
|
template<
|
|
typename FunctionPtr,
|
|
typename R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
|
>
|
|
struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
|
|
{
|
|
static BOOST_FUNCTION_VOID_RETURN_TYPE
|
|
invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_PARMS)
|
|
|
|
{
|
|
FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
|
|
BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
|
|
}
|
|
};
|
|
|
|
template<
|
|
typename FunctionObj,
|
|
typename R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
|
>
|
|
struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
|
|
{
|
|
static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
|
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.obj_ptr);
|
|
return (*f)(BOOST_FUNCTION_ARGS);
|
|
}
|
|
};
|
|
|
|
template<
|
|
typename FunctionObj,
|
|
typename R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
|
>
|
|
struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
|
|
{
|
|
static BOOST_FUNCTION_VOID_RETURN_TYPE
|
|
invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
|
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.obj_ptr);
|
|
BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
|
|
}
|
|
};
|
|
|
|
template<
|
|
typename FunctionObj,
|
|
typename R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
|
>
|
|
struct BOOST_FUNCTION_FUNCTION_REF_INVOKER
|
|
{
|
|
static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_PARMS)
|
|
|
|
{
|
|
FunctionObj* f =
|
|
reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
|
|
return (*f)(BOOST_FUNCTION_ARGS);
|
|
}
|
|
};
|
|
|
|
template<
|
|
typename FunctionObj,
|
|
typename R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
|
>
|
|
struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
|
|
{
|
|
static BOOST_FUNCTION_VOID_RETURN_TYPE
|
|
invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_PARMS)
|
|
|
|
{
|
|
FunctionObj* f =
|
|
reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
|
|
BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
|
|
}
|
|
};
|
|
|
|
template<
|
|
typename FunctionPtr,
|
|
typename R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
|
>
|
|
struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
|
|
{
|
|
typedef typename mpl::if_c<(is_void<R>::value),
|
|
BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
|
|
FunctionPtr,
|
|
R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
|
>,
|
|
BOOST_FUNCTION_FUNCTION_INVOKER<
|
|
FunctionPtr,
|
|
R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
|
>
|
|
>::type type;
|
|
};
|
|
|
|
template<
|
|
typename FunctionObj,
|
|
typename R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
|
>
|
|
struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
|
|
{
|
|
typedef typename mpl::if_c<(is_void<R>::value),
|
|
BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
|
|
FunctionObj,
|
|
R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
|
>,
|
|
BOOST_FUNCTION_FUNCTION_OBJ_INVOKER<
|
|
FunctionObj,
|
|
R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
|
>
|
|
>::type type;
|
|
};
|
|
|
|
template<
|
|
typename FunctionObj,
|
|
typename R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
|
>
|
|
struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
|
|
{
|
|
typedef typename mpl::if_c<(is_void<R>::value),
|
|
BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
|
|
FunctionObj,
|
|
R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
|
>,
|
|
BOOST_FUNCTION_FUNCTION_REF_INVOKER<
|
|
FunctionObj,
|
|
R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
|
>
|
|
>::type type;
|
|
};
|
|
|
|
/**
|
|
* vtable for a specific boost::function instance.
|
|
*/
|
|
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
|
struct BOOST_FUNCTION_VTABLE : vtable_base
|
|
{
|
|
#ifndef BOOST_NO_VOID_RETURNS
|
|
typedef R result_type;
|
|
#else
|
|
typedef typename function_return_type<R>::type result_type;
|
|
#endif // BOOST_NO_VOID_RETURNS
|
|
|
|
typedef result_type (*invoker_type)(function_buffer&
|
|
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)
|
|
{
|
|
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)
|
|
{
|
|
typedef typename get_function_tag<F>::type tag;
|
|
return assign_to_a(f, functor, a, tag());
|
|
}
|
|
|
|
void clear(function_buffer& functor)
|
|
{
|
|
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)
|
|
{
|
|
this->clear(functor);
|
|
if (f) {
|
|
// should be a reinterpret cast, but some compilers insist
|
|
// on giving cv-qualifiers to free functions
|
|
functor.func_ptr = (void (*)())(f);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
template<typename FunctionPtr,typename Allocator>
|
|
bool
|
|
assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
|
|
{
|
|
return assign_to(f,functor,function_ptr_tag());
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
// 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);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
template<typename MemberPtr,typename Allocator>
|
|
bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, 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.
|
|
if (f) {
|
|
this->assign_to_a(mem_fn(f), functor, a);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
#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 ((void*)&functor.data) FunctionObj(f);
|
|
}
|
|
template<typename FunctionObj,typename Allocator>
|
|
void
|
|
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
|
|
{
|
|
assign_functor(f,functor,mpl::true_());
|
|
}
|
|
|
|
// Assign to a function object allocated on the heap.
|
|
template<typename FunctionObj>
|
|
void
|
|
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
|
|
{
|
|
functor.obj_ptr = new FunctionObj(f);
|
|
}
|
|
template<typename FunctionObj,typename Allocator>
|
|
void
|
|
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
|
|
{
|
|
typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
|
|
typedef typename Allocator::template rebind<functor_wrapper_type>::other
|
|
wrapper_allocator_type;
|
|
typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
|
|
wrapper_allocator_type wrapper_allocator(a);
|
|
wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
|
|
wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
|
|
functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
|
|
functor.obj_ptr = new_f;
|
|
}
|
|
|
|
template<typename FunctionObj>
|
|
bool
|
|
assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
|
|
{
|
|
if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
|
|
assign_functor(f, functor,
|
|
mpl::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)
|
|
{
|
|
if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
|
|
assign_functor_a(f, functor, a,
|
|
mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
if (!boost::detail::function::has_empty_target(f.get_pointer())) {
|
|
// DPG TBD: We might need to detect constness of
|
|
// FunctionObj to assign into obj_ptr or const_obj_ptr to
|
|
// be truly legit, but no platform in existence makes
|
|
// const void* different from void*.
|
|
functor.const_obj_ptr = f.get_pointer();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
template<typename FunctionObj,typename Allocator>
|
|
bool
|
|
assign_to_a(const reference_wrapper<FunctionObj>& f,
|
|
function_buffer& functor, Allocator, function_obj_ref_tag)
|
|
{
|
|
return assign_to(f,functor,function_obj_ref_tag());
|
|
}
|
|
|
|
public:
|
|
invoker_type invoker;
|
|
};
|
|
} // end namespace function
|
|
} // end namespace detail
|
|
|
|
template<
|
|
typename R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
|
>
|
|
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
|
|
typedef R result_type;
|
|
#else
|
|
typedef typename boost::detail::function::function_return_type<R>::type
|
|
result_type;
|
|
#endif // BOOST_NO_VOID_RETURNS
|
|
|
|
private:
|
|
typedef boost::detail::function::BOOST_FUNCTION_VTABLE<
|
|
R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
|
|
vtable_type;
|
|
|
|
struct clear_type {};
|
|
|
|
public:
|
|
BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS);
|
|
|
|
// add signature for boost::lambda
|
|
template<typename Args>
|
|
struct sig
|
|
{
|
|
typedef result_type type;
|
|
};
|
|
|
|
#if BOOST_FUNCTION_NUM_ARGS == 1
|
|
typedef T0 argument_type;
|
|
#elif BOOST_FUNCTION_NUM_ARGS == 2
|
|
typedef T0 first_argument_type;
|
|
typedef T1 second_argument_type;
|
|
#endif
|
|
|
|
BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);
|
|
BOOST_FUNCTION_ARG_TYPES
|
|
|
|
typedef BOOST_FUNCTION_FUNCTION self_type;
|
|
|
|
BOOST_FUNCTION_FUNCTION() : function_base() { }
|
|
|
|
// MSVC chokes if the following two constructors are collapsed into
|
|
// one with a default parameter.
|
|
template<typename Functor>
|
|
BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
|
|
#ifndef BOOST_NO_SFINAE
|
|
,typename enable_if_c<
|
|
(boost::type_traits::ice_not<
|
|
(is_integral<Functor>::value)>::value),
|
|
int>::type = 0
|
|
#endif // BOOST_NO_SFINAE
|
|
) :
|
|
function_base()
|
|
{
|
|
this->assign_to(f);
|
|
}
|
|
template<typename Functor,typename Allocator>
|
|
BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
|
|
#ifndef BOOST_NO_SFINAE
|
|
,typename enable_if_c<
|
|
(boost::type_traits::ice_not<
|
|
(is_integral<Functor>::value)>::value),
|
|
int>::type = 0
|
|
#endif // BOOST_NO_SFINAE
|
|
) :
|
|
function_base()
|
|
{
|
|
this->assign_to_a(f,a);
|
|
}
|
|
|
|
#ifndef BOOST_NO_SFINAE
|
|
BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
|
|
#else
|
|
BOOST_FUNCTION_FUNCTION(int zero) : function_base()
|
|
{
|
|
BOOST_ASSERT(zero == 0);
|
|
}
|
|
#endif
|
|
|
|
BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base()
|
|
{
|
|
this->assign_to_own(f);
|
|
}
|
|
|
|
~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 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
|
|
// the return type of these assignment operators, but Borland C++ cannot
|
|
// handle BOOST_FUNCTION_FUNCTION as the type of the temporary to
|
|
// construct.
|
|
template<typename Functor>
|
|
#ifndef BOOST_NO_SFINAE
|
|
typename enable_if_c<
|
|
(boost::type_traits::ice_not<
|
|
(is_integral<Functor>::value)>::value),
|
|
BOOST_FUNCTION_FUNCTION&>::type
|
|
#else
|
|
BOOST_FUNCTION_FUNCTION&
|
|
#endif
|
|
operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
|
|
{
|
|
this->clear();
|
|
try {
|
|
this->assign_to(f);
|
|
} catch (...) {
|
|
vtable = 0;
|
|
throw;
|
|
}
|
|
return *this;
|
|
}
|
|
template<typename Functor,typename Allocator>
|
|
void assign(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a)
|
|
{
|
|
this->clear();
|
|
try {
|
|
this->assign_to_a(f,a);
|
|
} catch (...) {
|
|
vtable = 0;
|
|
throw;
|
|
}
|
|
}
|
|
|
|
#ifndef BOOST_NO_SFINAE
|
|
BOOST_FUNCTION_FUNCTION& operator=(clear_type*)
|
|
{
|
|
this->clear();
|
|
return *this;
|
|
}
|
|
#else
|
|
BOOST_FUNCTION_FUNCTION& operator=(int zero)
|
|
{
|
|
BOOST_ASSERT(zero == 0);
|
|
this->clear();
|
|
return *this;
|
|
}
|
|
#endif
|
|
|
|
// Assignment from another BOOST_FUNCTION_FUNCTION
|
|
BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
|
|
{
|
|
if (&f == this)
|
|
return *this;
|
|
|
|
this->clear();
|
|
try {
|
|
this->assign_to_own(f);
|
|
} catch (...) {
|
|
vtable = 0;
|
|
throw;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
void swap(BOOST_FUNCTION_FUNCTION& other)
|
|
{
|
|
if (&other == this)
|
|
return;
|
|
|
|
BOOST_FUNCTION_FUNCTION tmp = *this;
|
|
*this = other;
|
|
other = tmp;
|
|
}
|
|
|
|
// Clear out a target, if there is one
|
|
void clear()
|
|
{
|
|
if (vtable) {
|
|
static_cast<vtable_type*>(vtable)->clear(this->functor);
|
|
vtable = 0;
|
|
}
|
|
}
|
|
|
|
#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined 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 BOOST_FUNCTION_FUNCTION& f)
|
|
{
|
|
if (!f.empty()) {
|
|
this->vtable = f.vtable;
|
|
f.vtable->manager(f.functor, this->functor,
|
|
boost::detail::function::clone_functor_tag);
|
|
}
|
|
}
|
|
|
|
template<typename Functor>
|
|
void assign_to(Functor f)
|
|
{
|
|
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)
|
|
{
|
|
static vtable_type stored_vtable(f,a);
|
|
if (stored_vtable.assign_to_a(f, functor, a)) vtable = &stored_vtable;
|
|
else vtable = 0;
|
|
}
|
|
};
|
|
|
|
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
|
inline void swap(BOOST_FUNCTION_FUNCTION<
|
|
R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
|
>& f1,
|
|
BOOST_FUNCTION_FUNCTION<
|
|
R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
|
>& f2)
|
|
{
|
|
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<
|
|
R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_ARGS>&,
|
|
const BOOST_FUNCTION_FUNCTION<
|
|
R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_ARGS>&);
|
|
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
|
void operator!=(const BOOST_FUNCTION_FUNCTION<
|
|
R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_ARGS>&,
|
|
const BOOST_FUNCTION_FUNCTION<
|
|
R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_ARGS>& );
|
|
|
|
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
|
|
|
#if BOOST_FUNCTION_NUM_ARGS == 0
|
|
#define BOOST_FUNCTION_PARTIAL_SPEC R (void)
|
|
#else
|
|
#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))
|
|
#endif
|
|
|
|
template<typename R BOOST_FUNCTION_COMMA
|
|
BOOST_FUNCTION_TEMPLATE_PARMS>
|
|
class function<BOOST_FUNCTION_PARTIAL_SPEC>
|
|
: public BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
|
|
{
|
|
typedef BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS> base_type;
|
|
typedef function self_type;
|
|
|
|
struct clear_type {};
|
|
|
|
public:
|
|
|
|
function() : base_type() {}
|
|
|
|
template<typename Functor>
|
|
function(Functor f
|
|
#ifndef BOOST_NO_SFINAE
|
|
,typename enable_if_c<
|
|
(boost::type_traits::ice_not<
|
|
(is_integral<Functor>::value)>::value),
|
|
int>::type = 0
|
|
#endif
|
|
) :
|
|
base_type(f)
|
|
{
|
|
}
|
|
template<typename Functor,typename Allocator>
|
|
function(Functor f, Allocator a
|
|
#ifndef BOOST_NO_SFINAE
|
|
,typename enable_if_c<
|
|
(boost::type_traits::ice_not<
|
|
(is_integral<Functor>::value)>::value),
|
|
int>::type = 0
|
|
#endif
|
|
) :
|
|
base_type(f,a)
|
|
{
|
|
}
|
|
|
|
#ifndef 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)){}
|
|
|
|
self_type& operator=(const self_type& f)
|
|
{
|
|
self_type(f).swap(*this);
|
|
return *this;
|
|
}
|
|
|
|
template<typename Functor>
|
|
#ifndef BOOST_NO_SFINAE
|
|
typename enable_if_c<
|
|
(boost::type_traits::ice_not<
|
|
(is_integral<Functor>::value)>::value),
|
|
self_type&>::type
|
|
#else
|
|
self_type&
|
|
#endif
|
|
operator=(Functor f)
|
|
{
|
|
self_type(f).swap(*this);
|
|
return *this;
|
|
}
|
|
|
|
#ifndef 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;
|
|
}
|
|
};
|
|
|
|
#undef BOOST_FUNCTION_PARTIAL_SPEC
|
|
#endif // have partial specialization
|
|
|
|
} // end namespace boost
|
|
|
|
// Cleanup after ourselves...
|
|
#undef BOOST_FUNCTION_VTABLE
|
|
#undef BOOST_FUNCTION_COMMA
|
|
#undef BOOST_FUNCTION_FUNCTION
|
|
#undef BOOST_FUNCTION_FUNCTION_INVOKER
|
|
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
|
|
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
|
|
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
|
|
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
|
|
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_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_TEMPLATE_PARMS
|
|
#undef BOOST_FUNCTION_TEMPLATE_ARGS
|
|
#undef BOOST_FUNCTION_PARMS
|
|
#undef BOOST_FUNCTION_PARM
|
|
#undef BOOST_FUNCTION_ARGS
|
|
#undef BOOST_FUNCTION_ARG_TYPE
|
|
#undef BOOST_FUNCTION_ARG_TYPES
|
|
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
|
|
#undef BOOST_FUNCTION_RETURN
|
|
|
|
#if defined(BOOST_MSVC)
|
|
# pragma warning( pop )
|
|
#endif
|