feedc0de/boost_function
1
0
Fork 0
forked from boostorg/function
Code Pull Requests Activity

Remove uses of BOOST_FUNCTION_FUNCTION

Browse Source
This commit is contained in:
Peter Dimov
2024-01-28 02:29:30 +02:00
parent af8e66d03b
commit b13f8f6f20
1 changed files with 29 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
include/boost/function/function_template.hpp
View File

@ -27,7 +27,6 @@
#define BOOST_FUNCTION_COMMA , #define BOOST_FUNCTION_COMMA ,
// Class names used in this version of the code // Class names used in this version of the code
#define BOOST_FUNCTION_FUNCTION function_n
#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker #define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker
#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker #define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker
#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker #define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker
@ -637,7 +636,7 @@ namespace boost {
typename R BOOST_FUNCTION_COMMA typename R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_PARMS BOOST_FUNCTION_TEMPLATE_PARMS
> >
class BOOST_FUNCTION_FUNCTION : public function_base class function_n : public function_base
, public detail::function::variadic_function_base<T...> , public detail::function::variadic_function_base<T...>
{ {
public: public:
@ -665,14 +664,14 @@ namespace boost {
BOOST_STATIC_CONSTANT(int, arity = sizeof...(T)); BOOST_STATIC_CONSTANT(int, arity = sizeof...(T));
typedef BOOST_FUNCTION_FUNCTION self_type; typedef function_n self_type;
BOOST_DEFAULTED_FUNCTION(BOOST_FUNCTION_FUNCTION(), : function_base() {}) BOOST_DEFAULTED_FUNCTION(function_n(), : function_base() {})
// MSVC chokes if the following two constructors are collapsed into // MSVC chokes if the following two constructors are collapsed into
// one with a default parameter. // one with a default parameter.
template<typename Functor> template<typename Functor>
BOOST_FUNCTION_FUNCTION(Functor f function_n(Functor f
,typename boost::enable_if_< ,typename boost::enable_if_<
!(is_integral<Functor>::value), !(is_integral<Functor>::value),
int>::type = 0 int>::type = 0
@ -682,7 +681,7 @@ namespace boost {
this->assign_to(f); this->assign_to(f);
} }
template<typename Functor,typename Allocator> template<typename Functor,typename Allocator>
BOOST_FUNCTION_FUNCTION(Functor f, Allocator a function_n(Functor f, Allocator a
,typename boost::enable_if_< ,typename boost::enable_if_<
!(is_integral<Functor>::value), !(is_integral<Functor>::value),
int>::type = 0 int>::type = 0
@ -692,19 +691,19 @@ namespace boost {
this->assign_to_a(f,a); this->assign_to_a(f,a);
} }
BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { } function_n(clear_type*) : function_base() { }
BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base() function_n(const function_n& f) : function_base()
{ {
this->assign_to_own(f); this->assign_to_own(f);
} }
BOOST_FUNCTION_FUNCTION(BOOST_FUNCTION_FUNCTION&& f) : function_base() function_n(function_n&& f) : function_base()
{ {
this->move_assign(f); this->move_assign(f);
} }
~BOOST_FUNCTION_FUNCTION() { clear(); } ~function_n() { clear(); }
result_type operator()(BOOST_FUNCTION_PARMS) const result_type operator()(BOOST_FUNCTION_PARMS) const
{ {
@ -715,15 +714,15 @@ namespace boost {
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS); (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
} }
// The distinction between when to use BOOST_FUNCTION_FUNCTION and // The distinction between when to use function_n and
// when to use self_type is obnoxious. MSVC cannot handle self_type as // when to use self_type is obnoxious. MSVC cannot handle self_type as
// the return type of these assignment operators, but Borland C++ cannot // the return type of these assignment operators, but Borland C++ cannot
// handle BOOST_FUNCTION_FUNCTION as the type of the temporary to // handle function_n as the type of the temporary to
// construct. // construct.
template<typename Functor> template<typename Functor>
typename boost::enable_if_< typename boost::enable_if_<
!(is_integral<Functor>::value), !(is_integral<Functor>::value),
BOOST_FUNCTION_FUNCTION&>::type function_n&>::type
operator=(Functor f) operator=(Functor f)
{ {
this->clear(); this->clear();
@ -749,14 +748,14 @@ namespace boost {
BOOST_CATCH_END BOOST_CATCH_END
} }
BOOST_FUNCTION_FUNCTION& operator=(clear_type*) function_n& operator=(clear_type*)
{ {
this->clear(); this->clear();
return *this; return *this;
} }
// Assignment from another BOOST_FUNCTION_FUNCTION // Assignment from another function_n
BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f) function_n& operator=(const function_n& f)
{ {
if (&f == this) if (&f == this)
return *this; return *this;
@ -772,8 +771,8 @@ namespace boost {
return *this; return *this;
} }
// Move assignment from another BOOST_FUNCTION_FUNCTION // Move assignment from another function_n
BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f) function_n& operator=(function_n&& f)
{ {
if (&f == this) if (&f == this)
return *this; return *this;
@ -789,12 +788,12 @@ namespace boost {
return *this; return *this;
} }
void swap(BOOST_FUNCTION_FUNCTION& other) void swap(function_n& other)
{ {
if (&other == this) if (&other == this)
return; return;
BOOST_FUNCTION_FUNCTION tmp; function_n tmp;
tmp.move_assign(*this); tmp.move_assign(*this);
this->move_assign(other); this->move_assign(other);
other.move_assign(tmp); other.move_assign(tmp);
@ -813,7 +812,7 @@ namespace boost {
explicit operator bool () const { return !this->empty(); } explicit operator bool () const { return !this->empty(); }
private: private:
void assign_to_own(const BOOST_FUNCTION_FUNCTION& f) void assign_to_own(const function_n& f)
{ {
if (!f.empty()) { if (!f.empty()) {
this->vtable = f.vtable; this->vtable = f.vtable;
@ -911,7 +910,7 @@ namespace boost {
// Moves the value from the specified argument to *this. If the argument // Moves the value from the specified argument to *this. If the argument
// has its function object allocated on the heap, move_assign will pass // 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. // its buffer to *this, and set the argument's buffer pointer to NULL.
void move_assign(BOOST_FUNCTION_FUNCTION& f) void move_assign(function_n& f)
{ {
if (&f == this) if (&f == this)
return; return;
@ -960,11 +959,11 @@ namespace boost {
}; };
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS> template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
inline void swap(BOOST_FUNCTION_FUNCTION< inline void swap(function_n<
R BOOST_FUNCTION_COMMA R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS BOOST_FUNCTION_TEMPLATE_ARGS
>& f1, >& f1,
BOOST_FUNCTION_FUNCTION< function_n<
R BOOST_FUNCTION_COMMA R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS BOOST_FUNCTION_TEMPLATE_ARGS
>& f2) >& f2)
@ -974,17 +973,17 @@ namespace boost {
// Poison comparisons between boost::function objects of the same type. // Poison comparisons between boost::function objects of the same type.
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS> template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
void operator==(const BOOST_FUNCTION_FUNCTION< void operator==(const function_n<
R BOOST_FUNCTION_COMMA R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS>&, BOOST_FUNCTION_TEMPLATE_ARGS>&,
const BOOST_FUNCTION_FUNCTION< const function_n<
R BOOST_FUNCTION_COMMA R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS>&); BOOST_FUNCTION_TEMPLATE_ARGS>&);
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS> template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
void operator!=(const BOOST_FUNCTION_FUNCTION< void operator!=(const function_n<
R BOOST_FUNCTION_COMMA R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS>&, BOOST_FUNCTION_TEMPLATE_ARGS>&,
const BOOST_FUNCTION_FUNCTION< const function_n<
R BOOST_FUNCTION_COMMA R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS>& ); BOOST_FUNCTION_TEMPLATE_ARGS>& );
@ -993,9 +992,9 @@ template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
template<typename R BOOST_FUNCTION_COMMA template<typename R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_PARMS> BOOST_FUNCTION_TEMPLATE_PARMS>
class function<BOOST_FUNCTION_PARTIAL_SPEC> class function<BOOST_FUNCTION_PARTIAL_SPEC>
: public BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS> : public function_n<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
{ {
typedef BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS> base_type; typedef function_n<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS> base_type;
typedef function self_type; typedef function self_type;
struct clear_type {}; struct clear_type {};
@ -1081,7 +1080,6 @@ public:
// Cleanup after ourselves... // Cleanup after ourselves...
#undef BOOST_FUNCTION_VTABLE #undef BOOST_FUNCTION_VTABLE
#undef BOOST_FUNCTION_COMMA #undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
#undef BOOST_FUNCTION_FUNCTION_INVOKER #undef BOOST_FUNCTION_FUNCTION_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER #undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER #undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER