/usr/include/sigc++-2.0/sigc++/adaptors/deduce_result_type.h is in libsigc++-2.0-dev 2.10.0-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 | // -*- c++ -*-
/* Do not edit! -- generated file */
/*
*/
#ifndef _SIGC_ADAPTORS_DEDUCE_RESULT_TYPE_H_
#define _SIGC_ADAPTORS_DEDUCE_RESULT_TYPE_H_
#include <sigc++/functors/functor_trait.h>
namespace sigc {
/** A hint to the compiler.
* Functors which have all methods based on templates
* should publicly inherit from this hint and define
* a nested template class @p deduce_result_type that
* can be used to deduce the methods' return types.
*
* adaptor_base inherits from the functor_base hint so
* derived types should also have a result_type defined.
*
* Adaptors don't inherit from this type directly. They use
* use sigc::adapts as a base type instead. sigc::adaptors
* wraps arbitrary functor types as well as function pointers
* and class methods.
*
* @ingroup adaptors
*/
struct adaptor_base : public functor_base {};
/** Deduce the return type of a functor.
* <tt>typename deduce_result_type<functor_type, list of arg_types>::type</tt>
* deduces a functor's result type if @p functor_type inherits from
* sigc::functor_base and defines @p result_type or if @p functor_type
* is actually a (member) function type. Multi-type functors are not
* supported.
*
* sigc++ adaptors use
* <tt>typename deduce_result_type<functor_type, list of arg_types>::type</tt>
* to determine the return type of their <tt>templated operator()</tt> overloads.
*
* Adaptors in turn define a nested template class @p deduce_result_type
* that is used by template specializations of the global deduce_result_type
* template to correctly deduce the return types of the adaptor's suitable
* <tt>template operator()</tt> overload.
*
* @ingroup adaptors
*/
template<class T_functor, class... T_args>
struct deduce_result_type
{
//The compiler will choose this method overload if T_functor derives from adaptor_base,
//and if it has its own deduce_result_type member (which has its own ::type member).
template<class U_functor, typename = typename std::is_base_of<adaptor_base, T_functor>::type>
static
typename U_functor::template deduce_result_type<T_args...>::type
test();
//Otherwise, the compiler will choose this fallback method.
template<class U_functor>
static
typename functor_trait<T_functor>::result_type
test();
using type = decltype (test<T_functor> ());
};
template<typename T_functor, typename... T_args>
using deduce_result_t = typename deduce_result_type<T_functor, T_args...>::type;
} /* namespace sigc */
#endif /* _SIGC_ADAPTORS_DEDUCE_RESULT_TYPE_H_ */
|