untracked/sigc++/functors/functor_trait.h

   1 // -*- c++ -*-
   2 /* Do not edit! -- generated file */
   3 #ifndef _SIGC_FUNCTORS_FUNCTOR_TRAIT_H_
   4 #define _SIGC_FUNCTORS_FUNCTOR_TRAIT_H_
   5 #include <sigc++/type_traits.h>
   6 #include <type_traits>
   7
   8 namespace sigc {
   9
  10 //TODO: When we can break ABI, replace nil by something else, such as sigc_nil.
  11 // nil is a keyword in Objective C++. When gcc is used for compiling Objective C++
  12 // programs, nil is defined as a preprocessor macro.
  13 // https://bugzilla.gnome.org/show_bug.cgi?id=695235
  14 #if defined(nil) && defined(SIGC_PRAGMA_PUSH_POP_MACRO)
  15   #define SIGC_NIL_HAS_BEEN_PUSHED 1
  16   #pragma push_macro("nil")
  17   #undef nil
  18 #endif
  19
  20 /** nil struct type.
  21  * The nil struct type is used as default template argument in the
  22  * unnumbered sigc::signal and sigc::slot templates.
  23  *
  24  * @ingroup signal
  25  * @ingroup slot
  26  */
  27 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  28 struct nil;
  29 #else
  30 struct nil {};
  31 #endif
  32
  33 #ifdef SIGC_NIL_HAS_BEEN_PUSHED
  34   #undef SIGC_NIL_HAS_BEEN_PUSHED
  35   #pragma pop_macro("nil")
  36 #endif
  37
  38 /** @defgroup sigcfunctors Functors
  39  * Functors are copyable types that define operator()().
  40  *
  41  * Types that define operator()() overloads with different return types are referred to
  42  * as multi-type functors. Multi-type functors are only partially supported in libsigc++.
  43  *
  44  * Closures are functors that store all information needed to invoke a callback from operator()().
  45  *
  46  * Adaptors are functors that alter the signature of a functor's operator()().
  47  *
  48  * libsigc++ defines numerous functors, closures and adaptors.
  49  * Since libsigc++ is a callback library, most functors are also closures.
  50  * The documentation doesn't distinguish between functors and closures.
  51  *
  52  * The basic functor types libsigc++ provides are created with ptr_fun() and mem_fun()
  53  * and can be converted into slots implicitly.
  54  * The set of adaptors that ships with libsigc++ is documented in the @ref adaptors module.
  55  *
  56  * If you want to mix user-defined and third party functors with libsigc++,
  57  * and you want them to be implicitly convertible into slots, libsigc++ must know
  58  * the result type of your functors. There are different ways to achieve that.
  59  *
  60  * - Derive your functors from sigc::functor_base and place
  61  *   <tt>typedef T_return result_type;</tt> in the class definition.
  62  * - Use the macro SIGC_FUNCTOR_TRAIT(T_functor,T_return) in namespace sigc.
  63  *   Multi-type functors are only partly supported.
  64  * - For functors not derived from sigc::functor_base, and not specified with
  65  *   SIGC_FUNCTOR_TRAIT(), libsigc++ tries to deduce the result type with the
  66  *   C++11 decltype() specifier. That attempt usually succeeds if the functor
  67  *   has a single operator()(), but it fails if operator()() is overloaded.
  68  * - Use the macro #SIGC_FUNCTORS_HAVE_RESULT_TYPE, if you want libsigc++ to assume
  69  *   that result_type is defined in all user-defined or third party functors,
  70  *   whose result type can't be deduced in any other way.
  71  *
  72  * If all these ways to deduce the result type fail, void is assumed.
  73  *
  74  * With libsigc++ versions before 2.6, the macro
  75  * #SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE activated the test with
  76  * decltype(). That macro is now unneccesary and deprecated.
  77  */
  78
  79 /** A hint to the compiler.
  80  * All functors which define @p result_type should publically inherit from this hint.
  81  *
  82  * @ingroup sigcfunctors
  83  */
  84 struct functor_base {};
  85
  86 /** Helper class, to determine if decltype() can deduce the result type of a functor.
  87  *
  88  * @ingroup sigcfunctors
  89  */
  90 template <typename T_functor>
  91 class can_deduce_result_type_with_decltype
  92 {
  93 private:
  94   struct biggerthanint
  95   {
  96     int memory1;
  97     int memory2;
  98     int memory3;
  99     int memory4;
 100   };
 101
 102   static biggerthanint checksize(...);
 103
 104   // If decltype(&X_functor::operator()) can't be evaluated, this checksize() overload
 105   // is ignored because of the SFINAE rule (Substitution Failure Is Not An Error).
 106   template <typename X_functor>
 107   static int checksize(X_functor* obj, decltype(&X_functor::operator()) p = nullptr);
 108
 109 public:
 110   static const bool value
 111 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 112     = sizeof(checksize(static_cast<T_functor*>(nullptr))) == sizeof(int)
 113 #endif
 114     ;
 115 };
 116
 117
 118 /** Trait that specifies the return type of any type.
 119  * Template specializations for functors derived from sigc::functor_base,
 120  * for other functors whose result type can be deduced with decltype(),
 121  * for function pointers and for class methods are provided.
 122  *
 123  * @tparam T_functor Functor type.
 124  * @tparam I_derives_functor_base Whether @p T_functor inherits from sigc::functor_base.
 125  * @tparam I_can_use_decltype Whether the result type of @p T_functor can be deduced
 126  *                            with decltype().
 127  *
 128  * @ingroup sigcfunctors
 129  */
 130 template <class T_functor,
 131           bool I_derives_functor_base = std::is_base_of<functor_base,T_functor>::value,
 132           bool I_can_use_decltype = can_deduce_result_type_with_decltype<T_functor>::value>
 133 struct functor_trait
 134 {
 135   typedef void result_type;
 136   typedef T_functor functor_type;
 137 };
 138
 139 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 140 template <class T_functor, bool I_can_use_decltype>
 141 struct functor_trait<T_functor, true, I_can_use_decltype>
 142 {
 143   typedef typename T_functor::result_type result_type;
 144   typedef T_functor functor_type;
 145 };
 146
 147 template <typename T_functor>
 148 struct functor_trait<T_functor, false, true>
 149 {
 150   typedef typename functor_trait<decltype(&T_functor::operator()), false, false>::result_type result_type;
 151   typedef T_functor functor_type;
 152 };
 153 #endif // DOXYGEN_SHOULD_SKIP_THIS
 154
 155 /** Helper macro, if you want to mix user-defined and third party functors with libsigc++.
 156  *
 157  * If you want to mix functors not derived from sigc::functor_base with libsigc++, and
 158  * these functors define @p result_type, use this macro inside namespace sigc like so:
 159  * @code
 160  * namespace sigc { SIGC_FUNCTORS_HAVE_RESULT_TYPE }
 161  * @endcode
 162  *
 163  * @ingroup sigcfunctors
 164  */
 165 #define SIGC_FUNCTORS_HAVE_RESULT_TYPE                 \
 166 template <class T_functor>                             \
 167 struct functor_trait<T_functor, false, false>          \
 168 {                                                      \
 169   typedef typename T_functor::result_type result_type; \
 170   typedef T_functor functor_type;                      \
 171 };
 172
 173 /** Helper macro, if you want to mix user-defined and third party functors with libsigc++.
 174  *
 175  * If you want to mix functors not derived from sigc::functor_base with libsigc++, and
 176  * these functors don't define @p result_type, use this macro inside namespace sigc
 177  * to expose the return type of the functors like so:
 178  * @code
 179  * namespace sigc {
 180  *   SIGC_FUNCTOR_TRAIT(first_functor_type, return_type_of_first_functor_type)
 181  *   SIGC_FUNCTOR_TRAIT(second_functor_type, return_type_of_second_functor_type)
 182  *   ...
 183  * }
 184  * @endcode
 185  *
 186  * @ingroup sigcfunctors
 187  */
 188 #define SIGC_FUNCTOR_TRAIT(T_functor,T_return) \
 189 template <>                                    \
 190 struct functor_trait<T_functor, false, false>  \
 191 {                                              \
 192   typedef T_return result_type;                \
 193   typedef T_functor functor_type;              \
 194 };                                             \
 195 template <>                                    \
 196 struct functor_trait<T_functor, false, true>   \
 197 {                                              \
 198   typedef T_return result_type;                \
 199   typedef T_functor functor_type;              \
 200 };
 201
 202 #ifndef SIGCXX_DISABLE_DEPRECATED
 203 /** Helper macro, if you want to mix user-defined and third party functors with libsigc++.
 204  *
 205  * If you want to mix functors not derived from sigc::functor_base with libsigc++,
 206  * and your compiler can deduce the result type of the functor with the C++11
 207  * keyword <tt>decltype</tt>, use this macro inside namespace sigc like so:
 208  * @code
 209  * namespace sigc {
 210  *   SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE
 211  * }
 212  * @endcode
 213  *
 214  * Functors with overloaded operator()() are not supported.
 215  *
 216  * @newin{2,2,11}
 217  *
 218  * @deprecated This macro does nothing. The test it activated in libsigc++
 219  *             versions before 2.6, is now unconditionally activated.
 220  *
 221  * @ingroup sigcfunctors
 222  */
 223 #define SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE // Empty
 224 #endif // SIGCXX_DISABLE_DEPRECATED
 225
 226 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 227 // detect the return type and the functor version of non-functor types.
 228 template <class T_return> class pointer_functor0;
 229 template <class T_return>
 230 struct functor_trait<T_return (*)(), false, false>
 231 {
 232   typedef T_return result_type;
 233   typedef pointer_functor0<T_return> functor_type;
 234 };
 235
 236 template <class T_arg1, class T_return> class pointer_functor1;
 237 template <class T_arg1, class T_return>
 238 struct functor_trait<T_return (*)(T_arg1), false, false>
 239 {
 240   typedef T_return result_type;
 241   typedef pointer_functor1<T_arg1, T_return> functor_type;
 242 };
 243
 244 template <class T_arg1, class T_arg2, class T_return> class pointer_functor2;
 245 template <class T_arg1, class T_arg2, class T_return>
 246 struct functor_trait<T_return (*)(T_arg1, T_arg2), false, false>
 247 {
 248   typedef T_return result_type;
 249   typedef pointer_functor2<T_arg1, T_arg2, T_return> functor_type;
 250 };
 251
 252 template <class T_arg1, class T_arg2, class T_arg3, class T_return> class pointer_functor3;
 253 template <class T_arg1, class T_arg2, class T_arg3, class T_return>
 254 struct functor_trait<T_return (*)(T_arg1, T_arg2, T_arg3), false, false>
 255 {
 256   typedef T_return result_type;
 257   typedef pointer_functor3<T_arg1, T_arg2, T_arg3, T_return> functor_type;
 258 };
 259
 260 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return> class pointer_functor4;
 261 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return>
 262 struct functor_trait<T_return (*)(T_arg1, T_arg2, T_arg3, T_arg4), false, false>
 263 {
 264   typedef T_return result_type;
 265   typedef pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return> functor_type;
 266 };
 267
 268 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return> class pointer_functor5;
 269 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return>
 270 struct functor_trait<T_return (*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5), false, false>
 271 {
 272   typedef T_return result_type;
 273   typedef pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return> functor_type;
 274 };
 275
 276 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return> class pointer_functor6;
 277 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return>
 278 struct functor_trait<T_return (*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6), false, false>
 279 {
 280   typedef T_return result_type;
 281   typedef pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return> functor_type;
 282 };
 283
 284 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return> class pointer_functor7;
 285 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return>
 286 struct functor_trait<T_return (*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7), false, false>
 287 {
 288   typedef T_return result_type;
 289   typedef pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return> functor_type;
 290 };
 291
 292
 293 template <class T_return, class T_obj> class mem_functor0;
 294 template <class T_return, class T_obj> class const_mem_functor0;
 295 template <class T_return, class T_obj>
 296 struct functor_trait<T_return (T_obj::*)(), false, false>
 297 {
 298   typedef T_return result_type;
 299   typedef mem_functor0<T_return, T_obj> functor_type;
 300 };
 301 template <class T_return, class T_obj>
 302 struct functor_trait<T_return (T_obj::*)() const, false, false>
 303 {
 304   typedef T_return result_type;
 305   typedef const_mem_functor0<T_return, T_obj> functor_type;
 306 };
 307
 308 template <class T_return, class T_obj, class T_arg1> class mem_functor1;
 309 template <class T_return, class T_obj, class T_arg1> class const_mem_functor1;
 310 template <class T_arg1, class T_return, class T_obj>
 311 struct functor_trait<T_return (T_obj::*)(T_arg1), false, false>
 312 {
 313   typedef T_return result_type;
 314   typedef mem_functor1<T_return, T_obj, T_arg1> functor_type;
 315 };
 316 template <class T_arg1, class T_return, class T_obj>
 317 struct functor_trait<T_return (T_obj::*)(T_arg1) const, false, false>
 318 {
 319   typedef T_return result_type;
 320   typedef const_mem_functor1<T_return, T_obj, T_arg1> functor_type;
 321 };
 322
 323 template <class T_return, class T_obj, class T_arg1, class T_arg2> class mem_functor2;
 324 template <class T_return, class T_obj, class T_arg1, class T_arg2> class const_mem_functor2;
 325 template <class T_arg1, class T_arg2, class T_return, class T_obj>
 326 struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2), false, false>
 327 {
 328   typedef T_return result_type;
 329   typedef mem_functor2<T_return, T_obj, T_arg1, T_arg2> functor_type;
 330 };
 331 template <class T_arg1, class T_arg2, class T_return, class T_obj>
 332 struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2) const, false, false>
 333 {
 334   typedef T_return result_type;
 335   typedef const_mem_functor2<T_return, T_obj, T_arg1, T_arg2> functor_type;
 336 };
 337
 338 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> class mem_functor3;
 339 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> class const_mem_functor3;
 340 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
 341 struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3), false, false>
 342 {
 343   typedef T_return result_type;
 344   typedef mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> functor_type;
 345 };
 346 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
 347 struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3) const, false, false>
 348 {
 349   typedef T_return result_type;
 350   typedef const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> functor_type;
 351 };
 352
 353 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> class mem_functor4;
 354 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> class const_mem_functor4;
 355 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
 356 struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4), false, false>
 357 {
 358   typedef T_return result_type;
 359   typedef mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> functor_type;
 360 };
 361 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
 362 struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4) const, false, false>
 363 {
 364   typedef T_return result_type;
 365   typedef const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> functor_type;
 366 };
 367
 368 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> class mem_functor5;
 369 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> class const_mem_functor5;
 370 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
 371 struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5), false, false>
 372 {
 373   typedef T_return result_type;
 374   typedef mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> functor_type;
 375 };
 376 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
 377 struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const, false, false>
 378 {
 379   typedef T_return result_type;
 380   typedef const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> functor_type;
 381 };
 382
 383 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> class mem_functor6;
 384 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> class const_mem_functor6;
 385 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
 386 struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6), false, false>
 387 {
 388   typedef T_return result_type;
 389   typedef mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> functor_type;
 390 };
 391 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
 392 struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const, false, false>
 393 {
 394   typedef T_return result_type;
 395   typedef const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> functor_type;
 396 };
 397
 398 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> class mem_functor7;
 399 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> class const_mem_functor7;
 400 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
 401 struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7), false, false>
 402 {
 403   typedef T_return result_type;
 404   typedef mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> functor_type;
 405 };
 406 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
 407 struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const, false, false>
 408 {
 409   typedef T_return result_type;
 410   typedef const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> functor_type;
 411 };
 412
 413
 414 #endif // DOXYGEN_SHOULD_SKIP_THIS
 415
 416 } /* namespace sigc */
 417 #endif /* _SIGC_FUNCTORS_FUNCTOR_TRAIT_H_ */