tunnel_functor.h

Go to the documentation of this file.
00001 // -*- c++ -*-
00002 /* Do not edit! -- generated file */
00003 
00004 
00005 #ifndef _SIGXMACROS_TUNNEL_FUNCTOR_H_
00006 #define _SIGXMACROS_TUNNEL_FUNCTOR_H_
00007 
00008 
00009 /*
00010  * Copyright 2007 Klaus Triendl
00011  *
00012  * This library is free software; you can redistribute it and/or
00013  * modify it under the terms of the GNU Library General Public
00014  * License as published by the Free Software Foundation; either
00015  * version 2 of the License, or (at your option) any later version.
00016  *
00017  * This library is distributed in the hope that it will be useful,
00018  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00019  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00020  * Library General Public License for more details.
00021  *
00022  * You should have received a copy of the GNU Library General Public
00023  * License along with this library; if not, write to the Free
00024  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00025 */
00026 
00031 #include <sigc++/sigc++.h>
00032 #include <sigx/types.h>
00033 #include <sigx/internal_types.h>
00034 #include <sigx/tunnel_base.h>
00035 #include <sigx/tunnel_context.h>
00036 #include <sigx/ref.h>
00037 
00038 
00039 namespace sigx
00040 {
00041 
00042 
00043 template<sync_type I_sync, typename T_functor>
00044 struct tunnel_functor;
00045 
00081 template<typename T_functor>
00082 struct tunnel_functor<ASYNC, T_functor>: public sigc::adapts<T_functor>, public tunnel_base
00083 {
00084     typedef typename sigc::adapts<T_functor>::adaptor_type adaptor_type;
00085     typedef typename adaptor_type::result_type result_type;
00086 
00087     template<typename T_arg1 = void, typename T_arg2 = void, typename T_arg3 = void, typename T_arg4 = void, typename T_arg5 = void, typename T_arg6 = void, typename T_arg7 = void>
00088     struct deduce_result_type
00089     {
00090         // we could also use sigc::deduce_result_type but this saves another
00091         // level of indirection and does what sigc++ does internally
00092         typedef typename adaptor_type::template deduce_result_type<typename sigc::type_trait<T_arg1>::pass, typename sigc::type_trait<T_arg2>::pass, typename sigc::type_trait<T_arg3>::pass, typename sigc::type_trait<T_arg4>::pass, typename sigc::type_trait<T_arg5>::pass, typename sigc::type_trait<T_arg6>::pass, typename sigc::type_trait<T_arg7>::pass>::type type;
00093     };
00094 
00095 
00096     result_type operator()()
00097     {
00098         return make_new_tunnel_context<ASYNC, result_type>(m_disp, m_validity_tracker, this->functor_)->tunnel();
00099     }
00100 
00101     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00102     result_type sun_forte_workaround()
00103     {
00104         return make_new_tunnel_context<I_sync, result_type>(m_disp, m_validity_tracker, this->functor_)->tunnel();
00105     }
00106     #endif
00107 
00108     template<typename T_arg1>
00109     typename deduce_result_type<T_arg1>::type
00110     operator()(T_arg1 _A_arg1)
00111     {
00112         typedef typename deduce_result_type<T_arg1>::type deduced_result_type;
00113         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00114             sigc::bind(this->functor_, _A_arg1))->tunnel();
00115     }
00116 
00117     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00118     template<typename T_arg1>
00119     typename deduce_result_type<T_arg1>::type
00120     sun_forte_workaround(T_arg1 _A_arg1)
00121     {
00122         typedef typename deduce_result_type<T_arg1>::type deduced_result_type;
00123         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00124             sigc::bind(this->functor_, _A_arg1))->tunnel();
00125     }
00126     #endif
00127 
00128     template<typename T_arg1, typename T_arg2>
00129     typename deduce_result_type<T_arg1, T_arg2>::type
00130     operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
00131     {
00132         typedef typename deduce_result_type<T_arg1, T_arg2>::type deduced_result_type;
00133         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00134             sigc::bind(this->functor_, _A_arg1, _A_arg2))->tunnel();
00135     }
00136 
00137     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00138     template<typename T_arg1, typename T_arg2>
00139     typename deduce_result_type<T_arg1, T_arg2>::type
00140     sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
00141     {
00142         typedef typename deduce_result_type<T_arg1, T_arg2>::type deduced_result_type;
00143         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00144             sigc::bind(this->functor_, _A_arg1, _A_arg2))->tunnel();
00145     }
00146     #endif
00147 
00148     template<typename T_arg1, typename T_arg2, typename T_arg3>
00149     typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
00150     operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
00151     {
00152         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type deduced_result_type;
00153         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00154             sigc::bind(this->functor_, _A_arg1, _A_arg2, _A_arg3))->tunnel();
00155     }
00156 
00157     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00158     template<typename T_arg1, typename T_arg2, typename T_arg3>
00159     typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
00160     sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
00161     {
00162         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type deduced_result_type;
00163         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00164             sigc::bind(this->functor_, _A_arg1, _A_arg2, _A_arg3))->tunnel();
00165     }
00166     #endif
00167 
00168     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00169     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
00170     operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
00171     {
00172         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type deduced_result_type;
00173         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00174             sigc::bind(this->functor_, _A_arg1, _A_arg2, _A_arg3, _A_arg4))->tunnel();
00175     }
00176 
00177     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00178     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00179     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
00180     sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
00181     {
00182         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type deduced_result_type;
00183         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00184             sigc::bind(this->functor_, _A_arg1, _A_arg2, _A_arg3, _A_arg4))->tunnel();
00185     }
00186     #endif
00187 
00188     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00189     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
00190     operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
00191     {
00192         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type deduced_result_type;
00193         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00194             sigc::bind(this->functor_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5))->tunnel();
00195     }
00196 
00197     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00198     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00199     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
00200     sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
00201     {
00202         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type deduced_result_type;
00203         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00204             sigc::bind(this->functor_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5))->tunnel();
00205     }
00206     #endif
00207 
00208     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00209     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
00210     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)
00211     {
00212         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type deduced_result_type;
00213         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00214             sigc::bind(this->functor_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6))->tunnel();
00215     }
00216 
00217     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00218     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00219     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
00220     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)
00221     {
00222         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type deduced_result_type;
00223         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00224             sigc::bind(this->functor_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6))->tunnel();
00225     }
00226     #endif
00227 
00228     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00229     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
00230     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)
00231     {
00232         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type deduced_result_type;
00233         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00234             sigc::bind(this->functor_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, _A_arg7))->tunnel();
00235     }
00236 
00237     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00238     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00239     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
00240     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)
00241     {
00242         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type deduced_result_type;
00243         return make_new_tunnel_context<ASYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00244             sigc::bind(this->functor_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, _A_arg7))->tunnel();
00245     }
00246     #endif
00247 
00248 
00249     
00259     explicit tunnel_functor(typename sigc::type_trait<T_functor>::take _A_func): 
00260         sigc::adapts<T_functor>(_A_func), 
00261         // find the dispatchable object contained in the functor by 
00262         // stepping down the functor chain;
00263         // dispatchable_constraint finds the dispatchable and issues a compiler
00264         // error if the passed in functor is not a functor on a dispatchable's
00265         // method or does find a dispatchable in a SIGX_DISPATCH_WITH_FUNCTOR
00266         tunnel_base(internal::dispatchable_constraint<adaptor_type>::find_dispatchable(this->functor_))
00267     {}
00268     
00269     // implicit copy ctor is fine
00270     // implicit dtor is fine
00271     // implicit assignment operator is fine
00272 
00273 
00279     void activate_validity_tracking() const
00280     {
00281         validity_tracker().activate();
00282 
00283         // visit each trackable and bind the validity trackable to the sigc trackable and vice versa
00284         sigc::visit_each_type<sigc::trackable*>(
00285             sigc::mem_fun(validity_tracker(), &tunnel_validity_tracker::do_bind_to_trackable), 
00286             this->functor_
00287         );
00288     }
00289 };
00290 
00291 template<typename T_functor>
00292 struct tunnel_functor<SYNC, T_functor>: public sigc::adapts<T_functor>, public tunnel_base
00293 {
00294     typedef typename sigc::adapts<T_functor>::adaptor_type adaptor_type;
00295     typedef typename adaptor_type::result_type result_type;
00296 
00297     template<typename T_arg1 = void, typename T_arg2 = void, typename T_arg3 = void, typename T_arg4 = void, typename T_arg5 = void, typename T_arg6 = void, typename T_arg7 = void>
00298     struct deduce_result_type
00299     {
00300         // we could also use sigc::deduce_result_type but this saves another
00301         // level of indirection and does what sigc++ does internally
00302         typedef typename adaptor_type::template deduce_result_type<typename sigc::type_trait<T_arg1>::pass, typename sigc::type_trait<T_arg2>::pass, typename sigc::type_trait<T_arg3>::pass, typename sigc::type_trait<T_arg4>::pass, typename sigc::type_trait<T_arg5>::pass, typename sigc::type_trait<T_arg6>::pass, typename sigc::type_trait<T_arg7>::pass>::type type;
00303     };
00304 
00305 
00306     result_type operator()()
00307     {
00308         return make_new_tunnel_context<SYNC, result_type>(m_disp, m_validity_tracker, this->functor_)->tunnel();
00309     }
00310 
00311     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00312     result_type sun_forte_workaround()
00313     {
00314         return make_new_tunnel_context<I_sync, result_type>(m_disp, m_validity_tracker, this->functor_)->tunnel();
00315     }
00316     #endif
00317 
00318     template<typename T_arg1>
00319     typename deduce_result_type<T_arg1>::type
00320     operator()(T_arg1 _A_arg1)
00321     {
00322         typedef typename deduce_result_type<T_arg1>::type deduced_result_type;
00323         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00324             sigc::bind(this->functor_, sigx::ref(_A_arg1)))->tunnel();
00325     }
00326 
00327     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00328     template<typename T_arg1>
00329     typename deduce_result_type<T_arg1>::type
00330     sun_forte_workaround(T_arg1 _A_arg1)
00331     {
00332         typedef typename deduce_result_type<T_arg1>::type deduced_result_type;
00333         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00334             sigc::bind(this->functor_, sigx::ref(_A_arg1)))->tunnel();
00335     }
00336     #endif
00337 
00338     template<typename T_arg1, typename T_arg2>
00339     typename deduce_result_type<T_arg1, T_arg2>::type
00340     operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
00341     {
00342         typedef typename deduce_result_type<T_arg1, T_arg2>::type deduced_result_type;
00343         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00344             sigc::bind(this->functor_, sigx::ref(_A_arg1), sigx::ref(_A_arg2)))->tunnel();
00345     }
00346 
00347     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00348     template<typename T_arg1, typename T_arg2>
00349     typename deduce_result_type<T_arg1, T_arg2>::type
00350     sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
00351     {
00352         typedef typename deduce_result_type<T_arg1, T_arg2>::type deduced_result_type;
00353         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00354             sigc::bind(this->functor_, sigx::ref(_A_arg1), sigx::ref(_A_arg2)))->tunnel();
00355     }
00356     #endif
00357 
00358     template<typename T_arg1, typename T_arg2, typename T_arg3>
00359     typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
00360     operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
00361     {
00362         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type deduced_result_type;
00363         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00364             sigc::bind(this->functor_, sigx::ref(_A_arg1), sigx::ref(_A_arg2), sigx::ref(_A_arg3)))->tunnel();
00365     }
00366 
00367     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00368     template<typename T_arg1, typename T_arg2, typename T_arg3>
00369     typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
00370     sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
00371     {
00372         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type deduced_result_type;
00373         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00374             sigc::bind(this->functor_, sigx::ref(_A_arg1), sigx::ref(_A_arg2), sigx::ref(_A_arg3)))->tunnel();
00375     }
00376     #endif
00377 
00378     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00379     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
00380     operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
00381     {
00382         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type deduced_result_type;
00383         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00384             sigc::bind(this->functor_, sigx::ref(_A_arg1), sigx::ref(_A_arg2), sigx::ref(_A_arg3), sigx::ref(_A_arg4)))->tunnel();
00385     }
00386 
00387     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00388     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00389     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
00390     sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
00391     {
00392         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type deduced_result_type;
00393         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00394             sigc::bind(this->functor_, sigx::ref(_A_arg1), sigx::ref(_A_arg2), sigx::ref(_A_arg3), sigx::ref(_A_arg4)))->tunnel();
00395     }
00396     #endif
00397 
00398     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00399     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
00400     operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
00401     {
00402         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type deduced_result_type;
00403         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00404             sigc::bind(this->functor_, sigx::ref(_A_arg1), sigx::ref(_A_arg2), sigx::ref(_A_arg3), sigx::ref(_A_arg4), sigx::ref(_A_arg5)))->tunnel();
00405     }
00406 
00407     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00408     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00409     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
00410     sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
00411     {
00412         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type deduced_result_type;
00413         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00414             sigc::bind(this->functor_, sigx::ref(_A_arg1), sigx::ref(_A_arg2), sigx::ref(_A_arg3), sigx::ref(_A_arg4), sigx::ref(_A_arg5)))->tunnel();
00415     }
00416     #endif
00417 
00418     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00419     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
00420     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)
00421     {
00422         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type deduced_result_type;
00423         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00424             sigc::bind(this->functor_, sigx::ref(_A_arg1), sigx::ref(_A_arg2), sigx::ref(_A_arg3), sigx::ref(_A_arg4), sigx::ref(_A_arg5), sigx::ref(_A_arg6)))->tunnel();
00425     }
00426 
00427     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00428     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00429     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
00430     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)
00431     {
00432         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type deduced_result_type;
00433         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00434             sigc::bind(this->functor_, sigx::ref(_A_arg1), sigx::ref(_A_arg2), sigx::ref(_A_arg3), sigx::ref(_A_arg4), sigx::ref(_A_arg5), sigx::ref(_A_arg6)))->tunnel();
00435     }
00436     #endif
00437 
00438     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00439     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
00440     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)
00441     {
00442         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type deduced_result_type;
00443         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00444             sigc::bind(this->functor_, sigx::ref(_A_arg1), sigx::ref(_A_arg2), sigx::ref(_A_arg3), sigx::ref(_A_arg4), sigx::ref(_A_arg5), sigx::ref(_A_arg6), sigx::ref(_A_arg7)))->tunnel();
00445     }
00446 
00447     #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
00448     template<typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00449     typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
00450     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)
00451     {
00452         typedef typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type deduced_result_type;
00453         return make_new_tunnel_context<SYNC, deduced_result_type>(m_disp, m_validity_tracker, 
00454             sigc::bind(this->functor_, sigx::ref(_A_arg1), sigx::ref(_A_arg2), sigx::ref(_A_arg3), sigx::ref(_A_arg4), sigx::ref(_A_arg5), sigx::ref(_A_arg6), sigx::ref(_A_arg7)))->tunnel();
00455     }
00456     #endif
00457 
00458 
00459     
00469     explicit tunnel_functor(typename sigc::type_trait<T_functor>::take _A_func): 
00470         sigc::adapts<T_functor>(_A_func), 
00471         // find the dispatchable object contained in the functor by 
00472         // stepping down the functor chain;
00473         // dispatchable_constraint finds the dispatchable and issues a compiler
00474         // error if the passed in functor is not a functor on a dispatchable's
00475         // method or does find a dispatchable in a SIGX_DISPATCH_WITH_FUNCTOR
00476         tunnel_base(internal::dispatchable_constraint<adaptor_type>::find_dispatchable(this->functor_))
00477     {}
00478     
00479     // implicit copy ctor is fine
00480     // implicit dtor is fine
00481     // implicit assignment operator is fine
00482 
00483 
00489     void activate_validity_tracking() const
00490     {
00491         validity_tracker().activate();
00492 
00493         // visit each trackable and bind the validity trackable to the sigc trackable and vice versa
00494         sigc::visit_each_type<sigc::trackable*>(
00495             sigc::mem_fun(validity_tracker(), &tunnel_validity_tracker::do_bind_to_trackable), 
00496             this->functor_
00497         );
00498     }
00499 };
00500 
00501 
00502 
00503 
00504 
00510 template<typename T_functor>
00511 SIGX_DISPATCH_WITH_FUNCTOR(T_functor)
00512 dispatch_with(const T_functor& _A_func, const shared_dispatchable& d)
00513 {
00514     return sigc::bind(sigc::hide(_A_func), d);
00515 }
00516 
00517 
00527 template<typename T_functor>
00528 tunnel_functor<ASYNC, T_functor> 
00529 open_tunnel(const T_functor& _A_func)
00530 {
00531     return tunnel_functor<ASYNC, T_functor>(_A_func);
00532 }
00533 
00543 template<typename T_functor>
00544 tunnel_functor<SYNC, T_functor> 
00545 open_sync_tunnel(const T_functor& _A_func)
00546 {
00547     return tunnel_functor<SYNC, T_functor>(_A_func);
00548 }
00549 
00560 template<typename T_functor>
00561 tunnel_functor<ASYNC, SIGX_DISPATCH_WITH_FUNCTOR(T_functor)> 
00562 open_tunnel_with(const T_functor& _A_func, const shared_dispatchable& d)
00563 {
00564     return tunnel_functor<ASYNC, SIGX_DISPATCH_WITH_FUNCTOR(T_functor)>(dispatch_with(_A_func, d));
00565 }
00566 
00577 template<typename T_functor>
00578 tunnel_functor<SYNC, SIGX_DISPATCH_WITH_FUNCTOR(T_functor)> 
00579 open_sync_tunnel_with(const T_functor& _A_func, const shared_dispatchable& d)
00580 {
00581     return tunnel_functor<SYNC, SIGX_DISPATCH_WITH_FUNCTOR(T_functor)>(dispatch_with(_A_func, d));
00582 }
00583 
00584 
00585 } // namespace sigx
00586 
00587 
00588 namespace sigc
00589 {
00590 
00596 template<typename T_action, typename T_functor, sigx::sync_type I_sync>
00597 void visit_each(const T_action& /*_A_action*/, const sigx::tunnel_functor<I_sync, T_functor>& /*_A_func*/)
00598 {
00599     // do nothing
00600 }
00601 
00602 
00603 } // namespace sigc
00604 #endif /* _SIGXMACROS_TUNNEL_FUNCTOR_H_ */

Generated on Wed Jan 28 21:37:59 2009 for sigx++ by  doxygen 1.5.8