ReChannel: rc_abstract_accessor.h Source File

00001 // vim:set et sts=4 ts=4 tw=75 sw=4 ai ci cin cino=g0,t0:
00002 /*
00003  * Copyright (C) 2007, Technical Computer Science Group,
00004  *                     University of Bonn
00005  *
00006  * This file is part of the ReChannel library.
00007  *
00008  * The ReChannel library is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU General Public License as
00010  * published by the Free Software Foundation; either version 2 of the
00011  * License, or (at your option) any later version.
00012  *
00013  * This library is distributed in the hope that it will be
00014  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  * General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU General Public License
00019  * along with this library; see the file COPYING. If not, write to the
00020  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
00021  * Boston, MA 02110-1301, USA.
00022  *
00023  * Authors: Andreas Raabe and Armin Felke. Implementation by Armin Felke.
00024  *          {raabe, felke}@cs.uni-bonn.de
00025  */
00037 #ifndef RC_ABSTRACT_ACCESSOR_H_
00038 #define RC_ABSTRACT_ACCESSOR_H_
00039 
00040 #include "ReChannel/core/rc_common_header.h"
00041 #include "ReChannel/core/rc_process.h"
00042 #include "ReChannel/util/rc_hash_map.h"
00043 #include "ReChannel/communication/rc_report_ids.h"
00044 #include "ReChannel/communication/rc_fallback_interface.h"
00045 #include "ReChannel/communication/rc_interface_wrapper.h"
00046 
00047 namespace ReChannel {
00048 
00049 template<class IF> class rc_abstract_accessor;
00050 
00054 class rc_abstract_accessor_b
00055     : virtual public rc_interface_wrapper_base::accessor_base
00056 {
00057     template<class IF> friend class rc_abstract_accessor;
00058 
00059 private:
00060     typedef std::vector<sc_port_base*> port_vector;
00061     typedef std::map<sc_object*, int>  process_index_map;
00062 
00063 private:
00064     rc_abstract_accessor_b();
00065 
00066 public:
00067 
00068     virtual void register_port(
00069         sc_port_base& port_, const char* if_typename_);
00070 
00071     inline virtual rc_event_filter* rc_get_event_filter()
00072         { return NULL; }
00073 
00074     inline virtual int rc_get_bound_port_count() const
00075         { return p_bound_port_vector.size(); }
00076 
00077     inline virtual sc_port_base* rc_get_bound_port(int index) const
00078         { return p_bound_port_vector[index]; }
00079 
00080 protected:
00081 
00082     virtual bool rc_on_event(const sc_event& e)
00083         { return true; }
00084 
00085     virtual void rc_set_event_trigger(
00086         const sc_event& e, rc_event_trigger& t) { }
00087 
00088     virtual void rc_clear_event_trigger(const sc_event& e) { }
00089 
00090     int rc_get_driver_process_index(sc_object* proc) const;
00091 
00092     int rc_get_nb_driver_process_index(sc_object* proc) const;
00093 
00094     inline int rc_get_driver_process_count() const
00095         { return p_process_index_map.size(); }
00096 
00097     inline int rc_get_nb_driver_process_count() const
00098         { return p_nb_process_index_map.size(); }
00099 
00100 /* next_trigger(..) redirects */
00101 
00102     inline void next_trigger()
00103         { rc_next_trigger(); }
00104 
00105     inline void next_trigger(const sc_event& e)
00106         { rc_next_trigger(e); }
00107 
00108     inline void next_trigger(sc_event_or_list& el)
00109         { rc_next_trigger(el); }
00110 
00111     inline void next_trigger(sc_event_and_list& el)
00112         { rc_next_trigger(el); }
00113 
00114     inline void next_trigger(const sc_time& t)
00115         { rc_next_trigger(t); }
00116 
00117     inline void next_trigger(double v, sc_time_unit tu)
00118         { rc_next_trigger(v, tu); }
00119 
00120     inline void next_trigger(const sc_time& t, const sc_event& e)
00121         { rc_next_trigger(t, e); }
00122 
00123     inline void next_trigger(double v, sc_time_unit tu, const sc_event& e)
00124         { rc_next_trigger(v, tu, e); }
00125 
00126     inline void next_trigger(const sc_time& t, sc_event_or_list& el)
00127         { rc_next_trigger(t, el); }
00128 
00129     inline void next_trigger(
00130         double v, sc_time_unit t, sc_event_or_list& el)
00131         { rc_next_trigger(v, t, el); }
00132 
00133     inline void next_trigger(const sc_time& t, sc_event_and_list& el)
00134         { rc_next_trigger(t, el); }
00135 
00136     inline void next_trigger(
00137         double v, sc_time_unit tu, sc_event_and_list& el)
00138         { rc_next_trigger(v, tu, el); }
00139 
00140 /* rc_wait() redirects */
00141 
00142     inline void wait()
00143         { rc_wait(); }
00144 
00145     inline void wait(int n)
00146         { rc_wait(n); }
00147 
00148     inline void wait(const sc_event& e)
00149         { rc_wait(e); }
00150 
00151     inline void wait(sc_event_or_list& el)
00152         { rc_wait(el); }
00153 
00154     inline void wait(sc_event_and_list& el)
00155         { rc_wait(el); }
00156 
00157     inline void wait(const sc_time& t)
00158         { rc_wait(t); }
00159 
00160     inline void wait(double v, sc_time_unit tu)
00161         { rc_wait(v, tu); }
00162 
00163     inline void wait(const sc_time& t, const sc_event& e)
00164         { rc_wait(t, e); }
00165 
00166     inline void wait(double v, sc_time_unit tu, const sc_event& e)
00167         { rc_wait(v, tu, e); }
00168 
00169     inline void wait(const sc_time& t, sc_event_or_list& el)
00170         { rc_wait(t, el); }
00171 
00172     inline void wait(double v, sc_time_unit t, sc_event_or_list& el)
00173         { rc_wait(v, t, el); }
00174 
00175     inline void wait(const sc_time& t, sc_event_and_list& el)
00176         { rc_wait(t, el); }
00177 
00178     inline void wait(double v, sc_time_unit tu, sc_event_and_list& el)
00179         { rc_wait(v, tu, el); }
00180 
00181 private:
00182     int rc_register_driver_process(sc_object* proc);
00183 
00184     int rc_register_nb_driver_process(sc_object* proc);
00185 
00186 private:
00187     port_vector       p_bound_port_vector;
00188     process_index_map p_process_index_map;
00189     process_index_map p_nb_process_index_map;
00190 
00191 private:
00192     // disabled
00193     rc_abstract_accessor_b(const rc_abstract_accessor_b& accessor);
00194     rc_abstract_accessor_b& operator=(const rc_abstract_accessor_b& accessor);
00195 };
00196 
00197 /* interal helper macros for repetitive code generation */
00198 
00199 #define _RECHANNEL_ACCESSOR_NB_FW_(if_method_args, wrapper_call) \
00200     try { \
00201         if (p_target_if != NULL) { \
00202             return ((p_target_if->*method)if_method_args); \
00203         } else if (p_target_wrapper != NULL) { \
00204             return (wrapper_call); \
00205         } \
00206     } catch(rc_process_cancel_exception* e) { \
00207         rc_process_handle hproc = rc_get_current_process_handle(); \
00208         if (hproc.is_canceled()) { \
00209             ::ReChannel::rc_throw(e); \
00210         } else { \
00211             delete e; /* consume cancel exception */ \
00212         } \
00213     } \
00214     return ((rc_get_fallback_if().*method)if_method_args);
00215 
00216 #define _RECHANNEL_ACCESSOR_FW_(if_method_args, wrapper_call) \
00217     rc_process_handle hproc = rc_get_current_process_handle(); \
00218     while(true) { \
00219         try { \
00220             if (p_target_if != NULL) { \
00221                 rc_process_behavior_change temp = \
00222                     this->_rc_process_behavior_change(hproc); \
00223                 return ((p_target_if->*method)if_method_args); \
00224             } else if (p_target_wrapper != NULL) { \
00225                 return (wrapper_call); \
00226             } \
00227         } catch(rc_process_cancel_exception* e) { \
00228             if (hproc.is_canceled()) { \
00229                 ::ReChannel::rc_throw(e); \
00230             } else { \
00231                 delete e; /* consume cancel exception */ \
00232             } \
00233         } \
00234         this->_rc_wait_activation(); \
00235     }
00236 
00237 #define _RECHANNEL_ACCESSOR_NB_FW(if_method_args) \
00238     _RECHANNEL_ACCESSOR_NB_FW_( \
00239         if_method_args, \
00240         ((p_target_wrapper->get_nb_interface_access()->*method) \
00241             if_method_args))
00242 
00243 #define _RECHANNEL_ACCESSOR_FW(if_method_args) \
00244     _RECHANNEL_ACCESSOR_FW_( \
00245         if_method_args, \
00246         ((p_target_wrapper->get_interface_access()->*method) \
00247             if_method_args))
00248 
00249 #define _RECHANNEL_ACCESSOR_NB_FW_DRV(if_method_args, drv_call_args) \
00250     _RECHANNEL_ACCESSOR_NB_FW_( \
00251         if_method_args, \
00252         (p_target_wrapper->get_nb_driver_access( \
00253             _rc_nb_driver_process_index(sc_get_current_process_handle())) \
00254                 ->call drv_call_args))
00255 
00256 #define _RECHANNEL_ACCESSOR_FW_DRV(if_method_args, drv_call_args) \
00257     _RECHANNEL_ACCESSOR_FW_( \
00258         if_method_args, \
00259         (p_target_wrapper->get_driver_access( \
00260             _rc_driver_process_index(hproc))->call drv_call_args))
00261 
00265 template<class IF>
00266 class rc_abstract_accessor
00267     : public rc_abstract_accessor_b,
00268       virtual public rc_interface_wrapper<IF>::accessor
00269 {
00270     RC_STATIC_ASSERT_VALID_INTERFACE(IF);
00271 
00272 private:
00273     typedef typename
00274         rc_interface_wrapper<IF>::accessor::interface_access
00275             interface_access;
00276     typedef typename
00277         rc_interface_wrapper<IF>::accessor::nb_interface_access
00278             nb_interface_access;
00279     typedef typename rc_interface_wrapper<IF>::accessor::driver_access
00280         driver_access;
00281     typedef typename rc_interface_wrapper<IF>::accessor::nb_driver_access
00282         nb_driver_access;
00283 
00284     typedef rc_abstract_accessor<IF> this_type;
00285     typedef rc_abstract_accessor_b   base_type;
00286 
00287 public:
00288     typedef IF if_type;
00289 
00290 protected:
00291     explicit rc_abstract_accessor(
00292         rc_interface_wrapper<IF>* target_wrapper=NULL);
00293 
00294 public:
00295     virtual
00296         rc_interface_wrapper_base* rc_get_target_wrapper_base() const
00297         { return p_target_wrapper; }
00298 
00299     virtual rc_interface_wrapper<IF>* rc_get_target_wrapper() const
00300         { return p_target_wrapper; }
00301 
00302     virtual bool rc_set_target(rc_interface_wrapper_base& target);
00303 
00304     virtual bool rc_set_target(rc_interface_wrapper<IF>& target);
00305 
00306     virtual sc_interface* rc_get_target_interface() const
00307         { return p_target_if; }
00308 
00309     virtual bool rc_set_target(sc_interface& target);
00310 
00311     virtual bool rc_set_target(
00312         sc_interface& target, const rc_process_control& pctrl);
00313 
00314     virtual bool rc_set_target(IF& target);
00315 
00316     virtual bool rc_set_target(
00317         IF& target, const rc_process_control& pctrl);
00318 
00319     virtual void rc_clear_target();
00320 
00321     virtual void rc_on_target_changed() { }
00322 
00323     inline bool rc_has_target_wrapper() const
00324         { return (p_target_wrapper != NULL); }
00325 
00326     inline bool rc_has_target_interface() const
00327         { return (p_target_if != NULL); }
00328 
00329 protected:
00330     virtual IF& rc_get_fallback_if() const;
00331 
00332 /* non-blocking forwarder */
00333 
00334     template<class R, class IF_>
00335     inline R rc_nb_forward(R (IF_::*method)()) const
00336         { _RECHANNEL_ACCESSOR_NB_FW(()); }
00337 
00338     template<class R, class IF_>
00339     inline R rc_nb_forward(R (IF_::*method)() const) const
00340         { _RECHANNEL_ACCESSOR_NB_FW(()); }
00341 
00342     template<class R, class A1, class A1_, class IF_>
00343     inline R rc_nb_forward(R (IF_::*method)(A1_), A1 a1) const
00344         { _RECHANNEL_ACCESSOR_NB_FW((a1)); }
00345 
00346     template<class R, class A1, class A1_, class IF_>
00347     inline R rc_nb_forward(R (IF_::*method)(A1_) const, A1 a1) const
00348         { _RECHANNEL_ACCESSOR_NB_FW((a1)); }
00349 
00350     template<class R, class A1, class A2, class A1_, class A2_, class IF_>
00351     inline R rc_nb_forward(
00352         R (IF_::*method)(A1_, A2_), A1 a1, A2 a2) const
00353         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2)); }
00354 
00355     template<class R, class A1, class A2, class A1_, class A2_, class IF_>
00356     inline R rc_nb_forward(
00357         R (IF_::*method)(A1_, A2_) const, A1 a1, A2 a2) const
00358         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2)); }
00359 
00360     template<class R, class A1, class A2, class A3,
00361         class A1_, class A2_, class A3_, class IF_>
00362     inline R rc_nb_forward(
00363         R (IF_::*method)(A1_, A2_, A3_), A1 a1, A2 a2, A3 a3) const
00364         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3)); }
00365 
00366     template<class R, class A1, class A2, class A3,
00367         class A1_, class A2_, class A3_, class IF_>
00368     inline R rc_nb_forward(
00369         R (IF_::*method)(A1_, A2_, A3_) const,
00370         A1 a1, A2 a2, A3 a3) const
00371         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3)); }
00372 
00373     template<class R, class A1, class A2, class A3, class A4,
00374         class A1_, class A2_, class A3_, class A4_, class IF_>
00375     inline R rc_nb_forward(
00376         R (IF_::*method)(A1_, A2_, A3_, A4_),
00377         A1 a1, A2 a2, A3 a3, A4 a4) const
00378         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3, a4)); }
00379 
00380     template<class R, class A1, class A2, class A3, class A4,
00381         class A1_, class A2_, class A3_, class A4_, class IF_>
00382     inline R rc_nb_forward(
00383         R (IF_::*method)(A1_, A2_, A3_, A4_) const,
00384         A1 a1, A2 a2, A3 a3, A4 a4) const
00385         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3, a4)); }
00386 
00387     template<class R, class A1, class A2, class A3, class A4, class A5,
00388         class A1_, class A2_, class A3_, class A4_, class A5_,
00389         class IF_>
00390     inline R rc_nb_forward(
00391         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_),
00392         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
00393         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3, a4, a5)); }
00394 
00395     template<class R, class A1, class A2, class A3, class A4, class A5,
00396         class A1_, class A2_, class A3_, class A4_, class A5_,
00397         class IF_>
00398     inline R rc_nb_forward(
00399         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_) const,
00400         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
00401         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3, a4, a5)); }
00402 
00403     template<class R,
00404         class A1, class A2, class A3, class A4, class A5, class A6,
00405         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00406         class IF_>
00407     inline R rc_nb_forward(
00408         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_),
00409         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
00410         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3, a4, a5, a6)); }
00411 
00412     template<class R,
00413         class A1, class A2, class A3, class A4, class A5, class A6,
00414         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00415         class IF_>
00416     inline R rc_nb_forward(
00417         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_) const,
00418         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
00419         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3, a4, a5, a6)); }
00420 
00421     template<class R,
00422         class A1, class A2, class A3, class A4, class A5, class A6,
00423         class A7,
00424         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00425         class A7_, class IF_>
00426     inline R rc_nb_forward(
00427         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_),
00428         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
00429         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3, a4, a5, a6, a7)); }
00430 
00431     template<class R,
00432         class A1, class A2, class A3, class A4, class A5, class A6,
00433         class A7,
00434         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00435         class A7_, class IF_>
00436     inline R rc_nb_forward(
00437         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_) const,
00438         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
00439         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3, a4, a5, a6, a7)); }
00440 
00441     template<class R,
00442         class A1, class A2, class A3, class A4, class A5, class A6,
00443         class A7, class A8,
00444         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00445         class A7_, class A8_, class IF_>
00446     inline R rc_nb_forward(
00447         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_),
00448         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
00449         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3, a4, a5, a6, a7, a8)); }
00450 
00451     template<class R,
00452         class A1, class A2, class A3, class A4, class A5, class A6,
00453         class A7, class A8,
00454         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00455         class A7_, class A8_, class IF_>
00456     inline R rc_nb_forward(
00457         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_) const,
00458         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
00459         { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3, a4, a5, a6, a7, a8)); }
00460 
00461     template<class R,
00462         class A1, class A2, class A3, class A4, class A5, class A6,
00463         class A7, class A8, class A9,
00464         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00465         class A7_, class A8_, class A9_, class IF_>
00466     inline R rc_nb_forward(
00467         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_),
00468         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
00469         A7 a7, A8 a8, A9 a9)const
00470     { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
00471 
00472     template<class R,
00473         class A1, class A2, class A3, class A4, class A5, class A6,
00474         class A7, class A8, class A9,
00475         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00476         class A7_, class A8_, class A9_, class IF_>
00477     inline R rc_nb_forward(
00478         R (IF_::*method)(
00479             A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_) const,
00480         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
00481         A6 a6, A7 a7, A8 a8, A9 a9) const
00482     { _RECHANNEL_ACCESSOR_NB_FW((a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
00483 
00484     template<class R,
00485         class A1, class A2, class A3, class A4, class A5, class A6,
00486         class A7, class A8, class A9, class A10,
00487         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00488         class A7_, class A8_, class A9_, class A10_, class IF_>
00489     inline R rc_nb_forward(
00490         R (IF_::*method)(
00491             A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_, A10_),
00492         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
00493         A7 a7, A8 a8, A9 a9, A10 a10) const
00494     {
00495         _RECHANNEL_ACCESSOR_NB_FW(
00496             (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10));
00497     }
00498 
00499     template<class R,
00500         class A1, class A2, class A3, class A4, class A5, class A6,
00501         class A7, class A8, class A9, class A10,
00502         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00503         class A7_, class A8_, class A9_, class A10_, class IF_>
00504     inline R rc_nb_forward(
00505         R (IF_::*method)(
00506             A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_, A10_) const,
00507         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
00508         A7 a7, A8 a8, A9 a9, A10 a10) const
00509     {
00510         _RECHANNEL_ACCESSOR_NB_FW(
00511             (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10));
00512     }
00513 
00514 /* blocking forwarder */
00515 
00516     template<class R, class IF_>
00517     inline R rc_forward(R (IF_::*method)()) const
00518         { _RECHANNEL_ACCESSOR_FW(()); }
00519 
00520     template<class R, class IF_>
00521     inline R rc_forward(R (IF_::*method)() const) const
00522         { _RECHANNEL_ACCESSOR_FW(()); }
00523 
00524     template<class R, class A1, class A1_, class IF_>
00525     inline R rc_forward(R (IF_::*method)(A1_), A1 a1) const
00526         { _RECHANNEL_ACCESSOR_FW((a1)); }
00527 
00528     template<class R, class A1, class A1_, class IF_>
00529     inline R rc_forward(R (IF_::*method)(A1_) const, A1 a1) const
00530         { _RECHANNEL_ACCESSOR_FW((a1)); }
00531 
00532     template<class R, class A1, class A2, class A1_, class A2_, class IF_>
00533     inline R rc_forward(
00534         R (IF_::*method)(A1_, A2_), A1 a1, A2 a2) const
00535         { _RECHANNEL_ACCESSOR_FW((a1, a2)); }
00536 
00537     template<class R, class A1, class A2, class A1_, class A2_, class IF_>
00538     inline R rc_forward(
00539         R (IF_::*method)(A1_, A2_) const, A1 a1, A2 a2) const
00540         { _RECHANNEL_ACCESSOR_FW((a1, a2)); }
00541 
00542     template<class R, class A1, class A2, class A3,
00543         class A1_, class A2_, class A3_, class IF_>
00544     inline R rc_forward(
00545         R (IF_::*method)(A1_, A2_, A3_), A1 a1, A2 a2, A3 a3) const
00546         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3)); }
00547 
00548     template<class R, class A1, class A2, class A3,
00549         class A1_, class A2_, class A3_, class IF_>
00550     inline R rc_forward(
00551         R (IF_::*method)(A1_, A2_, A3_) const,
00552         A1 a1, A2 a2, A3 a3) const
00553         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3)); }
00554 
00555     template<class R, class A1, class A2, class A3, class A4,
00556         class A1_, class A2_, class A3_, class A4_, class IF_>
00557     inline R rc_forward(
00558         R (IF_::*method)(A1_, A2_, A3_, A4_),
00559         A1 a1, A2 a2, A3 a3, A4 a4) const
00560         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4)); }
00561 
00562     template<class R, class A1, class A2, class A3, class A4,
00563         class A1_, class A2_, class A3_, class A4_, class IF_>
00564     inline R rc_forward(
00565         R (IF_::*method)(A1_, A2_, A3_, A4_) const,
00566         A1 a1, A2 a2, A3 a3, A4 a4) const
00567         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4)); }
00568 
00569     template<class R, class A1, class A2, class A3, class A4, class A5,
00570         class A1_, class A2_, class A3_, class A4_, class A5_,
00571         class IF_>
00572     inline R rc_forward(
00573         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_),
00574         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
00575         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4, a5)); }
00576 
00577     template<class R, class A1, class A2, class A3, class A4, class A5,
00578         class A1_, class A2_, class A3_, class A4_, class A5_,
00579         class IF_>
00580     inline R rc_forward(
00581         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_) const,
00582         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
00583         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4, a5)); }
00584 
00585     template<class R,
00586         class A1, class A2, class A3, class A4, class A5, class A6,
00587         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00588         class IF_>
00589     inline R rc_forward(
00590         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_),
00591         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
00592         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4, a5, a6)); }
00593 
00594     template<class R,
00595         class A1, class A2, class A3, class A4, class A5, class A6,
00596         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00597         class IF_>
00598     inline R rc_forward(
00599         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_) const,
00600         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
00601         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4, a5, a6)); }
00602 
00603     template<class R,
00604         class A1, class A2, class A3, class A4, class A5, class A6,
00605         class A7,
00606         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00607         class A7_, class IF_>
00608     inline R rc_forward(
00609         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_),
00610         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
00611         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4, a5, a6, a7)); }
00612 
00613     template<class R,
00614         class A1, class A2, class A3, class A4, class A5, class A6,
00615         class A7,
00616         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00617         class A7_, class IF_>
00618     inline R rc_forward(
00619         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_) const,
00620         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
00621         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4, a5, a6, a7)); }
00622 
00623     template<class R,
00624         class A1, class A2, class A3, class A4, class A5, class A6,
00625         class A7, class A8,
00626         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00627         class A7_, class A8_, class IF_>
00628     inline R rc_forward(
00629         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_),
00630         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
00631         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4, a5, a6, a7, a8)); }
00632 
00633     template<class R,
00634         class A1, class A2, class A3, class A4, class A5, class A6,
00635         class A7, class A8,
00636         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00637         class A7_, class A8_, class IF_>
00638     inline R rc_forward(
00639         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_) const,
00640         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
00641         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4, a5, a6, a7, a8)); }
00642 
00643     template<class R,
00644         class A1, class A2, class A3, class A4, class A5, class A6,
00645         class A7, class A8, class A9,
00646         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00647         class A7_, class A8_, class A9_, class IF_>
00648     inline R rc_forward(
00649         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_),
00650         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
00651         A7 a7, A8 a8, A9 a9) const
00652         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
00653 
00654     template<class R,
00655         class A1, class A2, class A3, class A4, class A5, class A6,
00656         class A7, class A8, class A9,
00657         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00658         class A7_, class A8_, class A9_, class IF_>
00659     inline R rc_forward(
00660         R (IF_::*method)(
00661             A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_) const,
00662         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
00663         A7 a7, A8 a8, A9 a9) const
00664         { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
00665 
00666     template<class R,
00667         class A1, class A2, class A3, class A4, class A5, class A6,
00668         class A7, class A8, class A9, class A10,
00669         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00670         class A7_, class A8_, class A9_, class A10_, class IF_>
00671     inline R rc_forward(
00672         R (IF_::*method)(
00673             A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_, A10_),
00674         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
00675         A7 a7, A8 a8, A9 a9, A10 a10) const
00676     { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)); }
00677 
00678     template<class R,
00679         class A1, class A2, class A3, class A4, class A5, class A6,
00680         class A7, class A8, class A9, class A10,
00681         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00682         class A7_, class A8_, class A9_, class A10_, class IF_>
00683     inline R rc_forward(
00684         R (IF_::*method)(
00685             A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_, A10_) const,
00686         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
00687         A7 a7, A8 a8, A9 a9, A10 a10) const
00688     { _RECHANNEL_ACCESSOR_FW((a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)); }
00689 
00690 /* non-blocking driver forwarder (without return value) */
00691 
00692     template<class IF_>
00693     inline void rc_nb_forward_driver(void (IF_::*method)())
00694         { _RECHANNEL_ACCESSOR_NB_FW_DRV((), (method)); }
00695 
00696     template<class IF_>
00697     inline void rc_nb_forward_driver(void (IF_::*method)() const)
00698         { _RECHANNEL_ACCESSOR_NB_FW_DRV((), (method)); }
00699 
00700     template<class A1, class A1_, class IF_>
00701     inline void rc_nb_forward_driver(void (IF_::*method)(A1_), A1 a1)
00702         { _RECHANNEL_ACCESSOR_NB_FW_DRV((a1), (method, a1)); }
00703 
00704     template<class A1, class A1_, class IF_>
00705     inline void rc_nb_forward_driver(
00706         void (IF_::*method)(A1_) const, A1 a1)
00707         { _RECHANNEL_ACCESSOR_NB_FW_DRV((a1), (method, a1)); }
00708 
00709     template<class A1, class A2, class A1_, class A2_, class IF_>
00710     inline void rc_nb_forward_driver(
00711         void (IF_::*method)(A1_, A2_), A1 a1, A2 a2)
00712         { _RECHANNEL_ACCESSOR_NB_FW_DRV((a1, a2), (method, a1, a2)); }
00713 
00714     template<class A1, class A2, class A1_, class A2_, class IF_>
00715     inline void rc_nb_forward_driver(
00716         void (IF_::*method)(A1_, A2_) const, A1 a1, A2 a2)
00717         { _RECHANNEL_ACCESSOR_NB_FW_DRV((a1, a2), (method, a1, a2)); }
00718 
00719     template<class A1, class A2, class A3,
00720         class A1_, class A2_, class A3_, class IF_>
00721     inline void rc_nb_forward_driver(
00722         void (IF_::*method)(A1_, A2_, A3_), A1 a1, A2 a2, A3 a3)
00723     { _RECHANNEL_ACCESSOR_NB_FW_DRV((a1, a2, a3), (method, a1, a2, a3)); }
00724 
00725     template<class A1, class A2, class A3,
00726         class A1_, class A2_, class A3_, class IF_>
00727     inline void rc_nb_forward_driver(
00728         void (IF_::*method)(A1_, A2_, A3_) const, A1 a1, A2 a2, A3 a3)
00729     { _RECHANNEL_ACCESSOR_NB_FW_DRV((a1, a2, a3), (method, a1, a2, a3)); }
00730 
00731     template<class A1, class A2, class A3, class A4,
00732         class A1_, class A2_, class A3_, class A4_, class IF_>
00733     inline void rc_nb_forward_driver(
00734         void (IF_::*method)(A1_, A2_, A3_, A4_),
00735         A1 a1, A2 a2, A3 a3, A4 a4)
00736         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00737             (a1, a2, a3, a4), (method, a1, a2, a3, a4)); }
00738 
00739     template<class A1, class A2, class A3, class A4,
00740         class A1_, class A2_, class A3_, class A4_, class IF_>
00741     inline void rc_nb_forward_driver(
00742         void (IF_::*method)(A1_, A2_, A3_, A4_) const,
00743         A1 a1, A2 a2, A3 a3, A4 a4)
00744         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00745             (a1, a2, a3, a4), (method, a1, a2, a3, a4)); }
00746 
00747     template<class A1, class A2, class A3, class A4, class A5,
00748         class A1_, class A2_, class A3_, class A4_, class A5_, class IF_>
00749     inline void rc_nb_forward_driver(
00750         void (IF_::*method)(A1_, A2_, A3_, A4_, A5_),
00751         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
00752         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00753             (a1, a2, a3, a4, a5), (method, a1, a2, a3, a4, a5)); }
00754 
00755     template<class A1, class A2, class A3, class A4, class A5,
00756         class A1_, class A2_, class A3_, class A4_, class A5_, class IF_>
00757     inline void rc_nb_forward_driver(
00758         void (IF_::*method)(A1_, A2_, A3_, A4_, A5_) const,
00759         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
00760         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00761             (a1, a2, a3, a4, a5), (method, a1, a2, a3, a4, a5)); }
00762 
00763     template<class A1, class A2, class A3, class A4, class A5, class A6,
00764         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00765         class IF_>
00766     inline void rc_nb_forward_driver(
00767         void (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_),
00768         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
00769         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00770             (a1, a2, a3, a4, a5, a6), (method, a1, a2, a3, a4, a5, a6)); }
00771 
00772     template<class A1, class A2, class A3, class A4, class A5, class A6,
00773         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00774         class IF_>
00775     inline void rc_nb_forward_driver(
00776         void (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_) const,
00777         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
00778         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00779             (a1, a2, a3, a4, a5, a6), (method, a1, a2, a3, a4, a5, a6)); }
00780 
00781     template<class A1, class A2, class A3, class A4, class A5, class A6,
00782         class A7,
00783         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00784         class A7_, class IF_>
00785     inline void rc_nb_forward_driver(
00786         void (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_),
00787         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
00788         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00789             (a1, a2, a3, a4, a5, a6, a7),
00790             (method, a1, a2, a3, a4, a5, a6, a7)); }
00791 
00792     template<class A1, class A2, class A3, class A4, class A5, class A6,
00793         class A7,
00794         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00795         class A7_, class IF_>
00796     inline void rc_nb_forward_driver(
00797         void (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_) const,
00798         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
00799         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00800             (a1, a2, a3, a4, a5, a6, a7),
00801             (method, a1, a2, a3, a4, a5, a6, a7)); }
00802 
00803     template<class A1, class A2, class A3, class A4, class A5, class A6,
00804         class A7, class A8,
00805         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00806         class A7_, class A8_, class IF_>
00807     inline void rc_nb_forward_driver(
00808         void (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_),
00809         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
00810         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00811             (a1, a2, a3, a4, a5, a6, a7, a8),
00812             (method, a1, a2, a3, a4, a5, a6, a7, a8)); }
00813 
00814     template<class A1, class A2, class A3, class A4, class A5, class A6,
00815         class A7, class A8,
00816         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00817         class A7_, class A8_, class IF_>
00818     inline void rc_nb_forward_driver(
00819         void (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_) const,
00820         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
00821         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00822             (a1, a2, a3, a4, a5, a6, a7, a8),
00823             (method, a1, a2, a3, a4, a5, a6, a7, a8)); }
00824 
00825     template<class A1, class A2, class A3, class A4, class A5, class A6,
00826         class A7, class A8, class A9,
00827         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00828         class A7_, class A8_, class A9_, class IF_>
00829     inline void rc_nb_forward_driver(
00830         void (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_),
00831         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
00832         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00833             (a1, a2, a3, a4, a5, a6, a7, a8, a9),
00834             (method, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
00835 
00836     template<class A1, class A2, class A3, class A4, class A5, class A6,
00837         class A7, class A8, class A9,
00838         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00839         class A7_, class A8_, class A9_, class IF_>
00840     inline void rc_nb_forward_driver(
00841         void (IF_::*method)(
00842             A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_) const,
00843         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
00844         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00845             (a1, a2, a3, a4, a5, a6, a7, a8, a9),
00846             (method, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
00847 
00848     template<class A1, class A2, class A3, class A4, class A5, class A6,
00849         class A7, class A8, class A9, class A10,
00850         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00851         class A7_, class A8_, class A9_, class A10_, class IF_>
00852     inline void rc_nb_forward_driver(
00853         void (IF_::*method)(
00854             A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_, A10_),
00855         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
00856         A7 a7, A8 a8, A9 a9, A10 a10)
00857         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00858             (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10),
00859             (method, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)); }
00860 
00861     template<class A1, class A2, class A3, class A4, class A5, class A6,
00862         class A7, class A8, class A9, class A10,
00863         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00864         class A7_, class A8_, class A9_, class A10_, class IF_>
00865     inline void rc_nb_forward_driver(
00866         void (IF_::*method)(
00867             A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_, A10_) const,
00868         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
00869         A7 a7, A8 a8, A9 a9, A10 a10)
00870         { _RECHANNEL_ACCESSOR_NB_FW_DRV(
00871             (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10),
00872             (method, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)); }
00873 
00874 /* blocking driver forwarder */
00875 
00876     template<class R, class IF_>
00877     inline R rc_forward_driver(R (IF_::*method)())
00878         { _RECHANNEL_ACCESSOR_FW_DRV((), (method)); }
00879 
00880     template<class R, class IF_>
00881     inline R rc_forward_driver(R (IF_::*method)() const)
00882         { _RECHANNEL_ACCESSOR_FW_DRV((), (method)); }
00883 
00884     template<class R, class A1, class A1_, class IF_>
00885     inline R rc_forward_driver(R (IF_::*method)(A1_), A1 a1)
00886         { _RECHANNEL_ACCESSOR_FW_DRV((a1), (method, a1)); }
00887 
00888     template<class R, class A1, class A1_, class IF_>
00889     inline R rc_forward_driver(
00890         R (IF_::*method)(A1_) const, A1 a1)
00891         { _RECHANNEL_ACCESSOR_FW_DRV((a1), (method, a1)); }
00892 
00893     template<class R, class A1, class A2, class A1_, class A2_, class IF_>
00894     inline R rc_forward_driver(
00895         R (IF_::*method)(A1_, A2_), A1 a1, A2 a2)
00896         { _RECHANNEL_ACCESSOR_FW_DRV((a1, a2), (method, a1, a2)); }
00897 
00898     template<class R, class A1, class A2, class A1_, class A2_, class IF_>
00899     inline R rc_forward_driver(
00900         R (IF_::*method)(A1_, A2_) const, A1 a1, A2 a2)
00901         { _RECHANNEL_ACCESSOR_FW_DRV((a1, a2), (method, a1, a2)); }
00902 
00903     template<class R, class A1, class A2, class A3,
00904         class A1_, class A2_, class A3_, class IF_>
00905     inline R rc_forward_driver(
00906         R (IF_::*method)(A1_, A2_, A3_), A1 a1, A2 a2, A3 a3)
00907         { _RECHANNEL_ACCESSOR_FW_DRV((a1, a2, a3), (method, a1, a2, a3)); }
00908 
00909     template<class R, class A1, class A2, class A3,
00910         class A1_, class A2_, class A3_, class IF_>
00911     inline R rc_forward_driver(
00912         R (IF_::*method)(A1_, A2_, A3_) const, A1 a1, A2 a2, A3 a3)
00913         { _RECHANNEL_ACCESSOR_FW_DRV((a1, a2, a3), (method, a1, a2, a3)); }
00914 
00915     template<class R, class A1, class A2, class A3, class A4,
00916         class A1_, class A2_, class A3_, class A4_, class IF_>
00917     inline R rc_forward_driver(
00918         R (IF_::*method)(A1_, A2_, A3_, A4_),
00919         A1 a1, A2 a2, A3 a3, A4 a4)
00920         { _RECHANNEL_ACCESSOR_FW_DRV(
00921             (a1, a2, a3, a4), (method, a1, a2, a3, a4)); }
00922 
00923     template<class R, class A1, class A2, class A3, class A4,
00924         class A1_, class A2_, class A3_, class A4_, class IF_>
00925     inline R rc_forward_driver(
00926         R (IF_::*method)(A1_, A2_, A3_, A4_) const,
00927         A1 a1, A2 a2, A3 a3, A4 a4)
00928         { _RECHANNEL_ACCESSOR_FW_DRV(
00929             (a1, a2, a3, a4), (method, a1, a2, a3, a4)); }
00930 
00931     template<class R, class A1, class A2, class A3, class A4, class A5,
00932         class A1_, class A2_, class A3_, class A4_, class A5_, class IF_>
00933     inline R rc_forward_driver(
00934         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_),
00935         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
00936         { _RECHANNEL_ACCESSOR_FW_DRV(
00937             (a1, a2, a3, a4, a5), (method, a1, a2, a3, a4, a5)); }
00938 
00939     template<class R, class A1, class A2, class A3, class A4, class A5,
00940         class A1_, class A2_, class A3_, class A4_, class A5_, class IF_>
00941     inline R rc_forward_driver(
00942         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_) const,
00943         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
00944         { _RECHANNEL_ACCESSOR_FW_DRV(
00945             (a1, a2, a3, a4, a5), (method, a1, a2, a3, a4, a5)); }
00946 
00947     template<class R,
00948         class A1, class A2, class A3, class A4, class A5, class A6,
00949         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00950         class IF_>
00951     inline R rc_forward_driver(
00952         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_),
00953         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
00954         { _RECHANNEL_ACCESSOR_FW_DRV(
00955             (a1, a2, a3, a4, a5, a6), (method, a1, a2, a3, a4, a5, a6)); }
00956 
00957     template<class R,
00958         class A1, class A2, class A3, class A4, class A5, class A6,
00959         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00960         class IF_>
00961     inline R rc_forward_driver(
00962         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_) const,
00963         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
00964         { _RECHANNEL_ACCESSOR_FW_DRV(
00965             (a1, a2, a3, a4, a5, a6), (method, a1, a2, a3, a4, a5, a6)); }
00966 
00967     template<class R,
00968         class A1, class A2, class A3, class A4, class A5, class A6,
00969         class A7,
00970         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00971         class A7_, class IF_>
00972     inline R rc_forward_driver(
00973         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_),
00974         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
00975         { _RECHANNEL_ACCESSOR_FW_DRV(
00976             (a1, a2, a3, a4, a5, a6, a7),
00977             (method, a1, a2, a3, a4, a5, a6, a7)); }
00978 
00979     template<class R,
00980         class A1, class A2, class A3, class A4, class A5, class A6,
00981         class A7,
00982         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00983         class A7_, class IF_>
00984     inline R rc_forward_driver(
00985         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_) const,
00986         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
00987         { _RECHANNEL_ACCESSOR_FW_DRV(
00988             (a1, a2, a3, a4, a5, a6, a7),
00989             (method, a1, a2, a3, a4, a5, a6, a7)); }
00990 
00991     template<class R,
00992         class A1, class A2, class A3, class A4, class A5, class A6,
00993         class A7, class A8,
00994         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
00995         class A7_, class A8_, class IF_>
00996     inline R rc_forward_driver(
00997         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_),
00998         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
00999         { _RECHANNEL_ACCESSOR_FW_DRV(
01000             (a1, a2, a3, a4, a5, a6, a7, a8),
01001             (method, a1, a2, a3, a4, a5, a6, a7, a8)); }
01002 
01003     template<class R,
01004         class A1, class A2, class A3, class A4, class A5, class A6,
01005         class A7, class A8,
01006         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
01007         class A7_, class A8_, class IF_>
01008     inline R rc_forward_driver(
01009         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_) const,
01010         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
01011         { _RECHANNEL_ACCESSOR_FW_DRV(
01012             (a1, a2, a3, a4, a5, a6, a7, a8),
01013             (method, a1, a2, a3, a4, a5, a6, a7, a8)); }
01014 
01015     template<class R,
01016         class A1, class A2, class A3, class A4, class A5, class A6,
01017         class A7, class A8, class A9,
01018         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
01019         class A7_, class A8_, class A9_, class IF_>
01020     inline R rc_forward_driver(
01021         R (IF_::*method)(A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_),
01022         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
01023         { _RECHANNEL_ACCESSOR_FW_DRV(
01024             (a1, a2, a3, a4, a5, a6, a7, a8, a9),
01025             (method, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
01026 
01027     template<class R,
01028         class A1, class A2, class A3, class A4, class A5, class A6,
01029         class A7, class A8, class A9,
01030         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
01031         class A7_, class A8_, class A9_, class IF_>
01032     inline R rc_forward_driver(
01033         R (IF_::*method)(
01034             A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_) const,
01035         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
01036         { _RECHANNEL_ACCESSOR_FW_DRV(
01037             (a1, a2, a3, a4, a5, a6, a7, a8, a9),
01038             (method, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
01039 
01040     template<class R,
01041         class A1, class A2, class A3, class A4, class A5, class A6,
01042         class A7, class A8, class A9, class A10,
01043         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
01044         class A7_, class A8_, class A9_, class A10_, class IF_>
01045     inline R rc_forward_driver(
01046         R (IF_::*method)(
01047             A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_, A10_),
01048         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
01049         A7 a7, A8 a8, A9 a9, A10 a10)
01050         { _RECHANNEL_ACCESSOR_FW_DRV(
01051             (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10),
01052             (method, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)); }
01053 
01054     template<class R,
01055         class A1, class A2, class A3, class A4, class A5, class A6,
01056         class A7, class A8, class A9, class A10,
01057         class A1_, class A2_, class A3_, class A4_, class A5_, class A6_,
01058         class A7_, class A8_, class A9_, class A10_, class IF_>
01059     inline R rc_forward_driver(
01060         R (IF_::*method)(
01061             A1_, A2_, A3_, A4_, A5_, A6_, A7_, A8_, A9_, A10_) const,
01062         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
01063         A7 a7, A8 a8, A9 a9, A10 a10)
01064         { _RECHANNEL_ACCESSOR_FW_DRV(
01065             (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10),
01066             (method, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)); }
01067 
01068 private:
01069 
01070 /* for internal use only */
01071 
01072     rc_process_behavior_change _rc_process_behavior_change(
01073         rc_process_handle& hproc) const;
01074 
01075     void _rc_wait_activation() const;
01076 
01077     inline int _rc_driver_process_index(sc_process_handle& hproc);
01078 
01079     inline int _rc_nb_driver_process_index(sc_process_handle hproc);
01080 
01081 private:
01082     rc_interface_wrapper<IF>* p_target_wrapper;
01083     IF*                       p_target_if;
01084     sc_event                  p_target_set_event;
01085     const rc_process_control* p_pctrl;
01086 
01087 private:
01088     // disabled
01089     rc_abstract_accessor(const rc_abstract_accessor& accessor);
01090     rc_abstract_accessor& operator=(const rc_abstract_accessor& accessor);
01091 };
01092 
01093 #undef _RECHANNEL_ACCESSOR_NB_FW_
01094 #undef _RECHANNEL_ACCESSOR_FW_
01095 #undef _RECHANNEL_ACCESSOR_NB_FW
01096 #undef _RECHANNEL_ACCESSOR_FW
01097 #undef _RECHANNEL_ACCESSOR_NB_FW_DRV
01098 #undef _RECHANNEL_ACCESSOR_FW_DRV
01099 
01100 /* template code */
01101 
01102 template<class IF>
01103 rc_abstract_accessor<IF>::rc_abstract_accessor(
01104     rc_interface_wrapper<IF>* target_wrapper)
01105     : p_target_wrapper(target_wrapper), p_target_if(NULL), p_pctrl(NULL)
01106 { }
01107 
01108 template<class IF>
01109 bool rc_abstract_accessor<IF>::rc_set_target(
01110     rc_interface_wrapper<IF>& target)
01111 {
01112     this->rc_clear_target();
01113     p_target_wrapper = &target;
01114     rc_notify(p_target_set_event);
01115     return true;
01116 }
01117 
01118 template<class IF>
01119 bool rc_abstract_accessor<IF>::rc_set_target(
01120     rc_interface_wrapper_base& target)
01121 {
01122     rc_interface_wrapper<IF>* target_ =
01123         dynamic_cast<rc_interface_wrapper<IF>*>(&target);
01124     if (target_ != NULL) {
01125         return this->rc_set_target(*target_);
01126     } else {
01127         return false;
01128     }
01129 }
01130 
01131 template<class IF>
01132 bool rc_abstract_accessor<IF>::rc_set_target(IF& target)
01133 {
01134     this->rc_clear_target();
01135     p_target_if = &target;
01136     rc_notify(p_target_set_event);
01137     return true;
01138 }
01139 
01140 template<class IF>
01141 bool rc_abstract_accessor<IF>::rc_set_target(
01142     IF& target, const rc_process_control& pctrl)
01143 {
01144     this->rc_clear_target();
01145     p_target_if = &target;
01146     p_pctrl = &pctrl;
01147     rc_notify(p_target_set_event);
01148     return true;
01149 }
01150 
01151 template<class IF>
01152 bool rc_abstract_accessor<IF>::rc_set_target(sc_interface& target)
01153 {
01154     IF* target_ = dynamic_cast<IF*>(&target);
01155     if (target_ != NULL) {
01156         return this->rc_set_target(*target_);
01157     } else {
01158         return false;
01159     }
01160 }
01161 
01162 template<class IF>
01163 bool rc_abstract_accessor<IF>::rc_set_target(
01164     sc_interface& target, const rc_process_control& pctrl)
01165 {
01166     IF* target_ = dynamic_cast<IF*>(&target);
01167     if (target_ != NULL) {
01168         return this->rc_set_target(*target_, pctrl);
01169     } else {
01170         return false;
01171     }
01172 }
01173 
01174 template<class IF>
01175 void rc_abstract_accessor<IF>::rc_clear_target()
01176 {
01177     p_target_if = NULL;
01178     p_target_wrapper = NULL;
01179     p_pctrl = NULL;
01180     this->rc_on_target_changed();
01181 }
01182 
01183 template<class IF>
01184 IF& rc_abstract_accessor<IF>::rc_get_fallback_if() const
01185 {
01186     static IF* s_fallback_if =
01187         rc_fallback_interface_factory<IF>::create();
01188     if (s_fallback_if != NULL) {
01189         return *s_fallback_if;
01190     } else {
01191         RC_REPORT_ERROR(RC_ID_FALLBACK_INTERFACE_MISSING_,
01192             "a default fallback interface doesn't exist for this accessor");
01193     }
01194 }
01195 
01196 template<class IF>
01197 rc_process_behavior_change
01198 rc_abstract_accessor<IF>::_rc_process_behavior_change(
01199     rc_process_handle& hproc) const
01200 {
01201     if (p_pctrl != NULL) {
01202         return hproc.behavior_change(*p_pctrl);
01203     } else {
01204         return rc_process_behavior_change();
01205     }
01206 }
01207 
01208 template<class IF>
01209 void rc_abstract_accessor<IF>::_rc_wait_activation() const
01210 {
01211     if (p_pctrl == NULL) {
01212         rc_wait(p_target_set_event);
01213     } else {
01214         rc_wait(p_pctrl->get_activation_event());
01215     }
01216 }
01217 
01218 template<class IF>
01219 inline
01220 int rc_abstract_accessor<IF>::_rc_driver_process_index(
01221     sc_process_handle& hproc)
01222 {
01223     sc_object* proc = hproc.get_process_object();
01224     int index = rc_get_driver_process_index(proc);
01225     return (index == -1 ? rc_register_driver_process(proc) : index);
01226 }
01227 
01228 template<class IF>
01229 inline
01230 int rc_abstract_accessor<IF>::_rc_nb_driver_process_index(
01231     sc_process_handle hproc)
01232 {
01233     sc_object* proc = hproc.get_process_object();
01234     int index = rc_get_nb_driver_process_index(proc);
01235     return (index == -1 ? rc_register_nb_driver_process(proc) : index);
01236 }
01237 
01238 } // namespace ReChannel
01239 
01240 #endif // RC_ABSTRACT_ACCESSOR_H_
01241 
01242 //
01243 // $Id: rc_abstract_accessor.h,v 1.9 2008/01/01 13:47:20 felke Exp $
01244 // $Source: /var/cvs/projekte/ReChannel-v2/src/ReChannel/communication/accessors/rc_abstract_accessor.h,v $
01245 //