boostorg/function
1
0
Fork 1
mirror of https://github.com/boostorg/function.git synced 2025-07-29 12:27:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove BOOST_NO_SFINAE workarounds

Browse Source
This commit is contained in:
Peter Dimov
2024-01-27 06:58:05 +02:00
parent eff07e72c3
commit 509de96a1c
2 changed files with 0 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
include/boost/function/function_base.hpp
View File

@ -522,65 +522,6 @@ namespace boost {
// A type that is only used for comparisons against zero
struct useless_clear_type {};
#ifdef BOOST_NO_SFINAE
// These routines perform comparisons between a Boost.Function
// object and an arbitrary function object (when the last
// parameter is false_type) or against zero (when the
// last parameter is true_type). They are only necessary
// for compilers that don't support SFINAE.
template<typename Function, typename Functor>
bool
compare_equal(const Function& f, const Functor&, int, true_type)
{ return f.empty(); }
template<typename Function, typename Functor>
bool
compare_not_equal(const Function& f, const Functor&, int,
true_type)
{ return !f.empty(); }
template<typename Function, typename Functor>
bool
compare_equal(const Function& f, const Functor& g, long,
false_type)
{
if (const Functor* fp = f.template target<Functor>())
return function_equal(*fp, g);
else return false;
}
template<typename Function, typename Functor>
bool
compare_equal(const Function& f, const reference_wrapper<Functor>& g,
int, false_type)
{
if (const Functor* fp = f.template target<Functor>())
return fp == g.get_pointer();
else return false;
}
template<typename Function, typename Functor>
bool
compare_not_equal(const Function& f, const Functor& g, long,
false_type)
{
if (const Functor* fp = f.template target<Functor>())
return !function_equal(*fp, g);
else return true;
}
template<typename Function, typename Functor>
bool
compare_not_equal(const Function& f,
const reference_wrapper<Functor>& g, int,
false_type)
{
if (const Functor* fp = f.template target<Functor>())
return fp != g.get_pointer();
else return true;
}
#endif // BOOST_NO_SFINAE
/**
* Stores the "manager" portion of the vtable for a
* boost::function object.
@ -705,7 +646,6 @@ public:
# pragma clang diagnostic pop
#endif
#ifndef BOOST_NO_SFINAE
inline bool operator==(const function_base& f,
detail::function::useless_clear_type*)
{
@ -729,38 +669,6 @@ inline bool operator!=(detail::function::useless_clear_type*,
{
return !f.empty();
}
#endif
#ifdef BOOST_NO_SFINAE
// Comparisons between boost::function objects and arbitrary function objects
template<typename Functor>
inline bool operator==(const function_base& f, Functor g)
{
typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
return detail::function::compare_equal(f, g, 0, integral());
}
template<typename Functor>
inline bool operator==(Functor g, const function_base& f)
{
typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
return detail::function::compare_equal(f, g, 0, integral());
}
template<typename Functor>
inline bool operator!=(const function_base& f, Functor g)
{
typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
return detail::function::compare_not_equal(f, g, 0, integral());
}
template<typename Functor>
inline bool operator!=(Functor g, const function_base& f)
{
typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
return detail::function::compare_not_equal(f, g, 0, integral());
}
#else
// Comparisons between boost::function objects and arbitrary function
// objects.
@ -837,8 +745,6 @@ template<typename Functor>
else return true;
}
#endif // Compiler supporting SFINAE
namespace detail {
namespace function {
inline bool has_empty_target(const function_base* f)

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

@ -698,11 +698,9 @@ namespace boost {
// one with a default parameter.
template<typename Functor>
BOOST_FUNCTION_FUNCTION(Functor f
#ifndef BOOST_NO_SFINAE
,typename boost::enable_if_<
!(is_integral<Functor>::value),
int>::type = 0
#endif // BOOST_NO_SFINAE
) :
function_base()
{
@ -710,25 +708,16 @@ namespace boost {
}
template<typename Functor,typename Allocator>
BOOST_FUNCTION_FUNCTION(Functor f, Allocator a
#ifndef BOOST_NO_SFINAE
,typename boost::enable_if_<
!(is_integral<Functor>::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()
{
@ -759,13 +748,9 @@ namespace boost {
// handle BOOST_FUNCTION_FUNCTION as the type of the temporary to
// construct.
template<typename Functor>
#ifndef BOOST_NO_SFINAE
typename boost::enable_if_<
!(is_integral<Functor>::value),
BOOST_FUNCTION_FUNCTION&>::type
#else
BOOST_FUNCTION_FUNCTION&
#endif
operator=(Functor f)
{
this->clear();
@ -791,20 +776,11 @@ namespace boost {
BOOST_CATCH_END
}
#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)
@ -1082,30 +1058,24 @@ public:
template<typename Functor>
function(Functor f
#ifndef 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 BOOST_NO_SFINAE
,typename boost::enable_if_<
!(is_integral<Functor>::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)){}
@ -1132,26 +1102,20 @@ public:
#endif
template<typename Functor>
#ifndef 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 BOOST_NO_SFINAE
self_type& operator=(clear_type*)
{
this->clear();
return *this;
}
#endif
self_type& operator=(const base_type& f)
{