"Fossies" - the Fresh Open Source Software Archive

Member "libsigc++-2.10.2/sigc++/adaptors/adaptor_trait.h" (5 May 2019, 16645 Bytes) of package /linux/misc/libsigc++-2.10.2.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "adaptor_trait.h" see the Fossies "Dox" file reference documentation.

    1 // -*- c++ -*-
    2 /* Do not edit! -- generated file */
    3 #ifndef _SIGC_ADAPTORS_ADAPTOR_TRAIT_H_
    4 #define _SIGC_ADAPTORS_ADAPTOR_TRAIT_H_
    5 #include <sigc++config.h> //To get SIGC_TEMPLATE_KEYWORD_OPERATOR_OVERLOAD
    6 #include <sigc++/visit_each.h>
    7 #include <sigc++/functors/functor_trait.h>
    8 #include <sigc++/functors/ptr_fun.h>
    9 #include <sigc++/functors/mem_fun.h>
   10 #include <sigc++/adaptors/deduce_result_type.h>
   11 
   12 namespace sigc {
   13 
   14 // Call either operator()<>() or sun_forte_workaround<>(),
   15 // depending on the compiler:
   16 #ifdef SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   17   #define SIGC_WORKAROUND_OPERATOR_PARENTHESES template operator()
   18   #define SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   19 #else
   20   #ifdef SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   21     #define SIGC_WORKAROUND_OPERATOR_PARENTHESES operator()
   22     #define SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   23   #else
   24     #define SIGC_WORKAROUND_OPERATOR_PARENTHESES sun_forte_workaround
   25   #endif
   26 #endif
   27 
   28 
   29 #ifndef DOXYGEN_SHOULD_SKIP_THIS
   30 template <class T_functor> struct adapts;
   31 #endif
   32 
   33 /** @defgroup adaptors Adaptors
   34  * Adaptors are functors that alter the signature of a functor's
   35  * operator()().
   36  *
   37  * The adaptor types libsigc++ provides
   38  * are created with bind(), bind_return(), hide(), hide_return(),
   39  * retype_return(), retype(), compose(), exception_catch(), track_obj()
   40  * and group().
   41  *
   42  * You can easily derive your own adaptor type from sigc::adapts.
   43  */
   44 
   45 /** Converts an arbitrary functor into an adaptor type.
   46  * All adaptor types in libsigc++ have
   47  * a <tt>template operator()</tt> member of every argument count
   48  * they support. These functions in turn invoke a stored adaptor's
   49  * <tt>template operator()</tt>, processing the arguments and return
   50  * value in a characteristic manner. Explicit function template
   51  * instantiation is used to pass type hints thus saving copy costs.
   52  *
   53  * adaptor_functor is a glue between adaptors and arbitrary functors
   54  * that just passes on the arguments. You won't use this type directly.
   55  *
   56  * The template argument @e T_functor determines the type of stored
   57  * functor.
   58  *
   59  * @ingroup adaptors
   60  */
   61 template <class T_functor>
   62 struct adaptor_functor : public adaptor_base
   63 {
   64 #ifndef DOXYGEN_SHOULD_SKIP_THIS
   65   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
   66   struct deduce_result_type
   67     { typedef sigc::deduce_result_t<T_functor, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> type; };
   68 #endif
   69   typedef typename functor_trait<T_functor>::result_type result_type;
   70 
   71   /** Invokes the wrapped functor passing on the arguments.
   72    * @return The return value of the functor invocation.
   73    */
   74   result_type
   75   operator()() const;
   76 
   77   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   78   result_type sun_forte_workaround() const
   79     { return operator(); }
   80   #endif
   81 
   82   /** Invokes the wrapped functor passing on the arguments.
   83    * @param _A_arg1 Argument to be passed on to the functor.
   84    * @return The return value of the functor invocation.
   85    */
   86   template <class T_arg1>
   87   typename deduce_result_type<T_arg1>::type
   88   operator()(T_arg1 _A_arg1) const
   89     { return functor_(_A_arg1); }
   90 
   91   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   92   template <class T_arg1>
   93   typename deduce_result_type<T_arg1>::type
   94   sun_forte_workaround(T_arg1 _A_arg1) const
   95     { //Just calling operator() tries to copy the argument:
   96       return functor_(_A_arg1);
   97     }
   98   #endif
   99 
  100   /** Invokes the wrapped functor passing on the arguments.
  101    * @param _A_arg1 Argument to be passed on to the functor.
  102    * @param _A_arg2 Argument to be passed on to the functor.
  103    * @return The return value of the functor invocation.
  104    */
  105   template <class T_arg1, class T_arg2>
  106   typename deduce_result_type<T_arg1, T_arg2>::type
  107   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2) const
  108     { return functor_(_A_arg1, _A_arg2); }
  109 
  110   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  111   template <class T_arg1, class T_arg2>
  112   typename deduce_result_type<T_arg1, T_arg2>::type
  113   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2) const
  114     { //Just calling operator() tries to copy the argument:
  115       return functor_(_A_arg1, _A_arg2);
  116     }
  117   #endif
  118 
  119   /** Invokes the wrapped functor passing on the arguments.
  120    * @param _A_arg1 Argument to be passed on to the functor.
  121    * @param _A_arg2 Argument to be passed on to the functor.
  122    * @param _A_arg3 Argument to be passed on to the functor.
  123    * @return The return value of the functor invocation.
  124    */
  125   template <class T_arg1, class T_arg2, class T_arg3>
  126   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
  127   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3) const
  128     { return functor_(_A_arg1, _A_arg2, _A_arg3); }
  129 
  130   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  131   template <class T_arg1, class T_arg2, class T_arg3>
  132   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
  133   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3) const
  134     { //Just calling operator() tries to copy the argument:
  135       return functor_(_A_arg1, _A_arg2, _A_arg3);
  136     }
  137   #endif
  138 
  139   /** Invokes the wrapped functor passing on the arguments.
  140    * @param _A_arg1 Argument to be passed on to the functor.
  141    * @param _A_arg2 Argument to be passed on to the functor.
  142    * @param _A_arg3 Argument to be passed on to the functor.
  143    * @param _A_arg4 Argument to be passed on to the functor.
  144    * @return The return value of the functor invocation.
  145    */
  146   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
  147   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
  148   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4) const
  149     { return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4); }
  150 
  151   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  152   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
  153   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
  154   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4) const
  155     { //Just calling operator() tries to copy the argument:
  156       return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4);
  157     }
  158   #endif
  159 
  160   /** Invokes the wrapped functor passing on the arguments.
  161    * @param _A_arg1 Argument to be passed on to the functor.
  162    * @param _A_arg2 Argument to be passed on to the functor.
  163    * @param _A_arg3 Argument to be passed on to the functor.
  164    * @param _A_arg4 Argument to be passed on to the functor.
  165    * @param _A_arg5 Argument to be passed on to the functor.
  166    * @return The return value of the functor invocation.
  167    */
  168   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
  169   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
  170   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5) const
  171     { return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5); }
  172 
  173   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  174   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
  175   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
  176   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5) const
  177     { //Just calling operator() tries to copy the argument:
  178       return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
  179     }
  180   #endif
  181 
  182   /** Invokes the wrapped functor passing on the arguments.
  183    * @param _A_arg1 Argument to be passed on to the functor.
  184    * @param _A_arg2 Argument to be passed on to the functor.
  185    * @param _A_arg3 Argument to be passed on to the functor.
  186    * @param _A_arg4 Argument to be passed on to the functor.
  187    * @param _A_arg5 Argument to be passed on to the functor.
  188    * @param _A_arg6 Argument to be passed on to the functor.
  189    * @return The return value of the functor invocation.
  190    */
  191   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
  192   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
  193   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6) const
  194     { return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6); }
  195 
  196   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  197   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
  198   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
  199   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6) const
  200     { //Just calling operator() tries to copy the argument:
  201       return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
  202     }
  203   #endif
  204 
  205   /** Invokes the wrapped functor passing on the arguments.
  206    * @param _A_arg1 Argument to be passed on to the functor.
  207    * @param _A_arg2 Argument to be passed on to the functor.
  208    * @param _A_arg3 Argument to be passed on to the functor.
  209    * @param _A_arg4 Argument to be passed on to the functor.
  210    * @param _A_arg5 Argument to be passed on to the functor.
  211    * @param _A_arg6 Argument to be passed on to the functor.
  212    * @param _A_arg7 Argument to be passed on to the functor.
  213    * @return The return value of the functor invocation.
  214    */
  215   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
  216   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
  217   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7) const
  218     { return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, _A_arg7); }
  219 
  220   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  221   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
  222   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
  223   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7) const
  224     { //Just calling operator() tries to copy the argument:
  225       return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, _A_arg7);
  226     }
  227   #endif
  228 
  229   /// Constructs an invalid functor.
  230   adaptor_functor()
  231     {}
  232 
  233   /** Constructs an adaptor_functor object that wraps the passed functor.
  234    * @param _A_functor Functor to invoke from operator()().
  235    */
  236   explicit adaptor_functor(const T_functor& _A_functor)
  237     : functor_(_A_functor)
  238     {}
  239 
  240   /** Constructs an adaptor_functor object that wraps the passed (member)
  241    * function pointer.
  242    * @param _A_type Pointer to function or class method to invoke from operator()().
  243    */
  244   template <class T_type>
  245   explicit adaptor_functor(const T_type& _A_type)
  246     : functor_(_A_type)
  247     {}
  248 
  249   /// Functor that is invoked from operator()().
  250   mutable T_functor functor_;
  251 };
  252 
  253 template <class T_functor>
  254 typename adaptor_functor<T_functor>::result_type
  255 adaptor_functor<T_functor>::operator()() const
  256   { return functor_(); }
  257 
  258 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  259 //template specialization of visitor<>::do_visit_each<>(action, functor):
  260 /** Performs a functor on each of the targets of a functor.
  261  * The function overload for sigc::adaptor_functor performs a functor
  262  * on the functor stored in the sigc::adaptor_functor object.
  263  *
  264  * @ingroup adaptors
  265  */
  266 template <class T_functor>
  267 struct visitor<adaptor_functor<T_functor> >
  268 {
  269   template <class T_action>
  270   static void do_visit_each(const T_action& _A_action,
  271                             const adaptor_functor<T_functor>& _A_target)
  272   {
  273     sigc::visit_each(_A_action, _A_target.functor_);
  274   }
  275 };
  276 #endif // DOXYGEN_SHOULD_SKIP_THIS
  277 
  278 /** Trait that specifies what is the adaptor version of a functor type.
  279  * Template specializations for sigc::adaptor_base derived functors,
  280  * for function pointers and for class methods are provided.
  281  *
  282  * The template argument @e T_functor is the functor type to convert.
  283  * @e I_isadaptor indicates whether @e T_functor inherits from sigc::adaptor_base.
  284  *
  285  * @ingroup adaptors
  286  */
  287 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  288 template <class T_functor, bool I_isadaptor = std::is_base_of<adaptor_base, T_functor>::value> struct adaptor_trait;
  289 #else
  290 template <class T_functor, bool I_isadaptor = std::is_base_of<adaptor_base, T_functor>::value> struct adaptor_trait {};
  291 #endif
  292 
  293 /** Trait that specifies what is the adaptor version of a functor type.
  294  * This template specialization is used for types that inherit from adaptor_base.
  295  * adaptor_type is equal to @p T_functor in this case.
  296  */
  297 template <class T_functor>
  298 struct adaptor_trait<T_functor, true>
  299 {
  300   typedef typename T_functor::result_type result_type;
  301   typedef T_functor functor_type;
  302   typedef T_functor adaptor_type;
  303 };
  304 
  305 /** Trait that specifies what is the adaptor version of a functor type.
  306  * This template specialization is used for arbitrary functors,
  307  * for function pointers and for class methods are provided.
  308  * The latter are converted into @p pointer_functor or @p mem_functor types.
  309  * adaptor_type is equal to @p adaptor_functor<functor_type>.
  310  */
  311 template <class T_functor>
  312 struct adaptor_trait<T_functor, false>
  313 {
  314   typedef typename functor_trait<T_functor>::result_type result_type;
  315   typedef typename functor_trait<T_functor>::functor_type functor_type;
  316   typedef adaptor_functor<functor_type> adaptor_type;
  317 };
  318 
  319 // Doxygen (at least version 1.8.4) removes blank lines in a code block.
  320 // That's why there are empty comment lines in the following code block.
  321 /** Base type for adaptors.
  322  * sigc::adapts wraps adaptors, functors, function pointers and class methods.
  323  * It contains a single member functor which is always a sigc::adaptor_base.
  324  * The typedef adaptor_type defines the exact type that is used
  325  * to store the adaptor, functor, function pointer or class method passed
  326  * into the constructor. It differs from @a T_functor unless @a T_functor
  327  * inherits from sigc::adaptor_base.
  328  *
  329  * @par Example of a simple adaptor:
  330  * @code
  331  * namespace my_ns
  332  * {
  333  * template <class T_functor>
  334  * struct my_adaptor : public sigc::adapts<T_functor>
  335  * {
  336  *   template <class T_arg1=void, class T_arg2=void>
  337  *   struct deduce_result_type
  338  *   { typedef sigc::deduce_result_t<T_functor, T_arg1, T_arg2> type; };
  339  *   typedef typename sigc::functor_trait<T_functor>::result_type result_type;
  340  *   //
  341  *   result_type
  342  *   operator()() const;
  343  *   //
  344  *   template <class T_arg1>
  345  *   typename deduce_result_type<T_arg1>::type
  346  *   operator()(T_arg1 _A_arg1) const;
  347  *   //
  348  *   template <class T_arg1, class T_arg2>
  349  *   typename deduce_result_type<T_arg1, T_arg2>::type
  350  *   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2) const;
  351  *   //
  352  *   // Constructs a my_adaptor object that wraps the passed functor.
  353  *   // Initializes adapts<T_functor>::functor_, which is invoked from operator()().
  354  *   explicit my_adaptor(const T_functor& _A_functor)
  355  *     : sigc::adapts<T_functor>(_A_functor) {}
  356  * };
  357  * } // end namespace my_ns
  358  * //
  359  * // Specialization of sigc::visitor for my_adaptor.
  360  * namespace sigc
  361  * {
  362  * template <class T_functor>
  363  * struct visitor<my_ns::my_adaptor<T_functor> >
  364  * {
  365  *   template <class T_action>
  366  *   static void do_visit_each(const T_action& _A_action,
  367  *                             const my_ns::my_adaptor<T_functor>& _A_target)
  368  *   {
  369  *     sigc::visit_each(_A_action, _A_target.functor_);
  370  *   }
  371  * };
  372  * } // end namespace sigc
  373  * @endcode
  374  *
  375  * If you implement your own adaptor, you must also provide your specialization
  376  * of sigc::visitor<>::do_visit_each<>() that will forward the call to the functor(s)
  377  * your adapter is wrapping. Otherwise, pointers stored within the functor won't be
  378  * invalidated when a sigc::trackable object is destroyed and you can end up
  379  * executing callbacks on destroyed objects.
  380  *
  381  * Your specialization of sigc::visitor<> must be in namespace sigc.
  382  *
  383  * @ingroup adaptors
  384  */
  385 template <class T_functor>
  386 struct adapts : public adaptor_base
  387 {
  388   typedef typename adaptor_trait<T_functor>::result_type  result_type;
  389   typedef typename adaptor_trait<T_functor>::adaptor_type adaptor_type;
  390 
  391   /** Constructs an adaptor that wraps the passed functor.
  392    * @param _A_functor Functor to invoke from operator()().
  393    */
  394   explicit adapts(const T_functor& _A_functor)
  395     : functor_(_A_functor)
  396     {}
  397 
  398   /// Adaptor that is invoked from operator()().
  399   mutable adaptor_type functor_;
  400 };
  401 
  402 } /* namespace sigc */
  403 #endif /* _SIGC_ADAPTORS_ADAPTOR_TRAIT_H_ */