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/utility.hpp (3397B)

@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_DETAIL_UTILITY_HPP
#define BOOST_CLBL_TRTS_DETAIL_UTILITY_HPP

#include <boost/callable_traits/detail/config.hpp>
#include <boost/callable_traits/detail/sfinae_errors.hpp>
#include <boost/callable_traits/detail/qualifier_flags.hpp>

namespace boost { namespace callable_traits { namespace detail {

struct cdecl_tag{};
struct stdcall_tag{};
struct fastcall_tag{};
struct pascal_tag{};

struct invalid_type { invalid_type() = delete; };
struct reference_error { reference_error() = delete; };

template<typename T>
using error_type = typename std::conditional<
    std::is_reference<T>::value, reference_error, invalid_type>::type;

#ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS
struct abominable_functions_not_supported_on_this_compiler{};
#endif

// used to convey "this type doesn't matter" in code
struct dummy {};

// used as return type in failed SFINAE tests
struct substitution_failure : std::false_type{};

template<bool Value>
using bool_type = std::integral_constant<bool, Value>;

// shorthand for std::tuple_element
template<std::size_t I, typename Tup>
using at = typename std::tuple_element<I, Tup>::type;

template<typename T, typename Class>
using add_member_pointer = T Class::*;

template<typename L, typename R, typename ErrorType>
 using fail_when_same = fail_if<std::is_same<L, R>::value, ErrorType>;

template<typename T, typename ErrorType,
    typename U = typename std::remove_reference<T>::type>
using try_but_fail_if_invalid = sfinae_try<T,
    fail_when_same<U, invalid_type, ErrorType>,
    fail_when_same<U, reference_error,
        reference_type_not_supported_by_this_metafunction>>;

template<typename T, typename ErrorType,
    typename U = typename std::remove_reference<T>::type,
    bool is_reference_error = std::is_same<reference_error, U>::value>
using fail_if_invalid = fail_if<
    std::is_same<U, invalid_type>::value || is_reference_error,
    typename std::conditional<is_reference_error,
        reference_type_not_supported_by_this_metafunction, ErrorType>::type>;

template<typename T, typename Fallback>
using fallback_if_invalid = typename std::conditional<
    std::is_same<T, invalid_type>::value, Fallback, T>::type;

template<typename T, template<class> class Alias, typename U = Alias<T>>
struct force_sfinae {
    using type = U;
};

template<typename T>
using shallow_decay = typename std::remove_cv<
    typename std::remove_reference<T>::type>::type;

template<typename T>
struct is_reference_wrapper_t {
    using type = std::false_type;
};

template<typename T>
struct is_reference_wrapper_t<std::reference_wrapper<T>> {
    using type = std::true_type;
};

template<typename T>
using is_reference_wrapper =
    typename is_reference_wrapper_t<shallow_decay<T>>::type;

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

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

// removes std::reference_wrapper
template<typename T>
using unwrap_reference = typename unwrap_reference_t<T>::type;

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

#endif // #ifndef BOOST_CLBL_TRTS_DETAIL_UTILITY_HPP

/* @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_DETAIL_UTILITY_HPP #define BOOST_CLBL_TRTS_DETAIL_UTILITY_HPP #include #include #include namespace boost { namespace callable_traits { namespace detail { struct cdecl_tag{}; struct stdcall_tag{}; struct fastcall_tag{}; struct pascal_tag{}; struct invalid_type { invalid_type() = delete; }; struct reference_error { reference_error() = delete; }; template using error_type = typename std::conditional< std::is_reference::value, reference_error, invalid_type>::type; #ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS struct abominable_functions_not_supported_on_this_compiler{}; #endif // used to convey "this type doesn't matter" in code struct dummy {}; // used as return type in failed SFINAE tests struct substitution_failure : std::false_type{}; template using bool_type = std::integral_constant; // shorthand for std::tuple_element template using at = typename std::tuple_element::type; template using add_member_pointer = T Class::*; template using fail_when_same = fail_if::value, ErrorType>; template::type> using try_but_fail_if_invalid = sfinae_try, fail_when_same>; template::type, bool is_reference_error = std::is_same::value> using fail_if_invalid = fail_if< std::is_same::value || is_reference_error, typename std::conditional::type>; template using fallback_if_invalid = typename std::conditional< std::is_same::value, Fallback, T>::type; template class Alias, typename U = Alias> struct force_sfinae { using type = U; }; template using shallow_decay = typename std::remove_cv< typename std::remove_reference::type>::type; template struct is_reference_wrapper_t { using type = std::false_type; }; template struct is_reference_wrapper_t> { using type = std::true_type; }; template using is_reference_wrapper = typename is_reference_wrapper_t>::type; template struct unwrap_reference_t { using type = T; }; template struct unwrap_reference_t> { using type = decltype(std::declval().get()); }; // removes std::reference_wrapper template using unwrap_reference = typename unwrap_reference_t::type; }}} // namespace boost::callable_traits::detail #endif // #ifndef BOOST_CLBL_TRTS_DETAIL_UTILITY_HPP