FM / detail

/usr/include/boost/callable_traits/detail/

/usr/include/boost/callable_traits/detail

Name	Size	Mode	Actions
polyfills/	-	0755	rm
unguarded/	-	0755	rm
config.hpp	3549	0644	edit dl rm
core.hpp	626	0644	edit dl rm
default_callable_traits.hpp	7666	0644	edit dl rm
forward_declarations.hpp	1480	0644	edit dl rm
function.hpp	6865	0644	edit dl rm
function_object.hpp	3491	0644	edit dl rm
is_invocable_impl.hpp	5111	0644	edit dl rm
parameter_index_helper.hpp	1883	0644	edit dl rm
pmd.hpp	1559	0644	edit dl rm
pmf.hpp	3660	0644	edit dl rm
qualifier_flags.hpp	4742	0644	edit dl rm
set_function_qualifiers.hpp	6317	0644	edit dl rm
sfinae_errors.hpp	3471	0644	edit dl rm
traits.hpp	823	0644	edit dl rm
utility.hpp	3397	0644	edit dl rm

Edit: /usr/include/boost/callable_traits/detail/is_invocable_impl.hpp (5111B)

/*!
@file

@Copyright Barrett Adair 2015-2017
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)

#ifndef BOOST_CLBL_TRTS_IS_INVOCABLE_IMPL_HPP
#define BOOST_CLBL_TRTS_IS_INVOCABLE_IMPL_HPP

#include <boost/callable_traits/detail/config.hpp>
#include <boost/callable_traits/detail/forward_declarations.hpp>
#include <boost/callable_traits/detail/utility.hpp>
#include <type_traits>
#include <utility>

namespace boost { namespace callable_traits { namespace detail {

template<typename T>
    struct can_dereference_t
    {
        template<typename>
        struct check {};

template<typename U>
        static std::int8_t test(
            check<typename std::remove_reference<decltype(*std::declval<U>())>::type>*
        );

template<typename>
        static std::int16_t test(...);

static constexpr const bool value =
            sizeof(test<T>(nullptr)) == sizeof(std::int8_t);
    };

//returns std::true_type for pointers and smart pointers
    template<typename T>
    using can_dereference = std::integral_constant<bool,
        can_dereference_t<T>::value>;

template<typename T, typename = std::true_type>
    struct generalize_t {
        using type = T;
    };

template<typename T>
    struct generalize_t<T, std::integral_constant<bool,
            can_dereference<T>::value && !is_reference_wrapper<T>::value
    >>{
        using type = decltype(*std::declval<T>());
    };

template<typename T>
    struct generalize_t<T, is_reference_wrapper<T>> {
        using type = decltype(std::declval<T>().get());
    };

// When T is a pointer, generalize<T> is the resulting type of the
    // pointer dereferenced. When T is an std::reference_wrapper, generalize<T>
    // is the underlying reference type. Otherwise, generalize<T> is T.
    template<typename T>
    using generalize = typename generalize_t<T>::type;

// handles the member pointer rules of INVOKE
    template<typename Base, typename T,
             typename IsBaseOf = std::is_base_of<Base, shallow_decay<T>>,
             typename IsSame = std::is_same<Base, shallow_decay<T>>>
    using generalize_if_dissimilar = typename std::conditional<
        IsBaseOf::value || IsSame::value, T, generalize<T>>::type;

template<typename Traits, bool = Traits::is_const_member::value
        || Traits::is_volatile_member::value
        || Traits::is_lvalue_reference_member::value
        || Traits::is_rvalue_reference_member::value>
    struct test_invoke {

template<typename... Rgs,
            typename U = typename Traits::type>
        auto operator()(int, Rgs&&... rgs) const ->
            success<decltype(std::declval<U>()(static_cast<Rgs&&>(rgs)...))>;

auto operator()(long, ...) const -> substitution_failure;
    };

template<typename F>
    struct test_invoke<function<F>, true /*abominable*/> {
        auto operator()(...) const -> substitution_failure;
    };

template<typename Pmf, bool Ignored>
    struct test_invoke<pmf<Pmf>, Ignored> {

using class_t = typename pmf<Pmf>::class_type;

template<typename U, typename... Rgs,
            typename Obj = generalize_if_dissimilar<class_t, U&&>>
        auto operator()(int, U&& u, Rgs&&... rgs) const ->
            success<decltype((std::declval<Obj>().*std::declval<Pmf>())(static_cast<Rgs&&>(rgs)...))>;

auto operator()(long, ...) const -> substitution_failure;
    };

template<typename Pmd, bool Ignored>
    struct test_invoke<pmd<Pmd>, Ignored> {

using class_t = typename pmd<Pmd>::class_type;

template<typename U,
            typename Obj = generalize_if_dissimilar<class_t, U&&>>
        auto operator()(int, U&& u) const ->
            success<decltype(std::declval<Obj>().*std::declval<Pmd>())>;

auto operator()(long, ...) const -> substitution_failure;
    };

template<typename T, typename... Args>
    struct is_invocable_impl {
        using traits = detail::traits<T>;
        using test = detail::test_invoke<traits>;
        using result = decltype(test{}(0, ::std::declval<Args>()...));
        using type = std::integral_constant<bool, result::value>;
    };

template<typename... Args>
    struct is_invocable_impl<void, Args...> {
        using type = std::false_type;
    };

template<typename IsInvocable, typename Ret, typename T, typename... Args>
    struct is_invocable_r_impl {
        using traits = detail::traits<T>;
        using test = detail::test_invoke<traits>;
        using result = decltype(test{}(0, ::std::declval<Args>()...));
        using type = std::integral_constant<bool,
            std::is_convertible<typename result::_::type, Ret>::value
                || std::is_same<Ret, void>::value>;
    };

template<typename Ret, typename T, typename... Args>
    struct is_invocable_r_impl<std::false_type, Ret, T, Args...> {
        using type = std::false_type;
    };

}}} // namespace boost::callable_traits::detail

#endif // #ifndef BOOST_CLBL_TRTS_IS_INVOCABLE_IMPL_HPP

/*! @file @Copyright Barrett Adair 2015-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_CLBL_TRTS_IS_INVOCABLE_IMPL_HPP #define BOOST_CLBL_TRTS_IS_INVOCABLE_IMPL_HPP #include #include #include #include #include namespace boost { namespace callable_traits { namespace detail { template struct can_dereference_t { template struct check {}; template static std::int8_t test( check())>::type>* ); template static std::int16_t test(...); static constexpr const bool value = sizeof(test(nullptr)) == sizeof(std::int8_t); }; //returns std::true_type for pointers and smart pointers template using can_dereference = std::integral_constant::value>; template struct generalize_t { using type = T; }; template struct generalize_t::value && !is_reference_wrapper::value >>{ using type = decltype(*std::declval()); }; template struct generalize_t> { using type = decltype(std::declval().get()); }; // When T is a pointer, generalize is the resulting type of the // pointer dereferenced. When T is an std::reference_wrapper, generalize // is the underlying reference type. Otherwise, generalize is T. template using generalize = typename generalize_t::type; // handles the member pointer rules of INVOKE template>, typename IsSame = std::is_same>> using generalize_if_dissimilar = typename std::conditional< IsBaseOf::value || IsSame::value, T, generalize>::type; template struct test_invoke { template auto operator()(int, Rgs&&... rgs) const -> success()(static_cast(rgs)...))>; auto operator()(long, ...) const -> substitution_failure; }; template struct test_invoke, true /*abominable*/> { auto operator()(...) const -> substitution_failure; }; template struct test_invoke, Ignored> { using class_t = typename pmf::class_type; template> auto operator()(int, U&& u, Rgs&&... rgs) const -> success().*std::declval())(static_cast(rgs)...))>; auto operator()(long, ...) const -> substitution_failure; }; template struct test_invoke, Ignored> { using class_t = typename pmd::class_type; template> auto operator()(int, U&& u) const -> success().*std::declval())>; auto operator()(long, ...) const -> substitution_failure; }; template struct is_invocable_impl { using traits = detail::traits; using test = detail::test_invoke; using result = decltype(test{}(0, ::std::declval()...)); using type = std::integral_constant; }; template struct is_invocable_impl { using type = std::false_type; }; template struct is_invocable_r_impl { using traits = detail::traits; using test = detail::test_invoke; using result = decltype(test{}(0, ::std::declval()...)); using type = std::integral_constant::value || std::is_same::value>; }; template struct is_invocable_r_impl { using type = std::false_type; }; }}} // namespace boost::callable_traits::detail #endif // #ifndef BOOST_CLBL_TRTS_IS_INVOCABLE_IMPL_HPP