ReChannel: rc_reconfigurable_module.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_RECONFIGURABLE_MODULE_H_
00038 #define RC_RECONFIGURABLE_MODULE_H_
00039 
00040 #include "ReChannel/core/rc_reconfigurable.h"
00041 #include "ReChannel/core/rc_process_support.h"
00042 
00043 #include <boost/type_traits/is_base_of.hpp>
00044 
00045 namespace ReChannel {
00046 
00047 #define RC_STATIC_ASSERT_VALID_MODULE(module_type) \
00048     RC_STATIC_ASSERT_T( \
00049         module_type_validity_check, \
00050         (boost::is_base_of<sc_module, module_type >::value \
00051          || boost::is_same<sc_module, module_type>::value) \
00052     )
00053 
00054 template<
00055     class Module=sc_module,
00056     bool _rc_resettable=boost::is_base_of<rc_resettable, Module>::value
00057 >
00058 class rc_reconfigurable_module;
00059 
00095 template<class Module>
00096 class rc_reconfigurable_module<Module, true>
00097     : public rc_reconfigurable,
00098       private internals::reconfigurable::begin_construction,
00099       public Module
00100 {
00106     RC_STATIC_ASSERT_VALID_MODULE(Module);
00107 
00108 private:
00109     typedef typename internals::reconfigurable::begin_construction
00110         begin_construction;
00111 public:
00112 
00116     typedef Module module_type;
00117 
00118 public:
00122     rc_reconfigurable_module();
00123 
00127     rc_reconfigurable_module(sc_module_name module_name);
00128 
00129     template<class A1>
00130     rc_reconfigurable_module(A1 a1);
00131 
00132     template<class A1, class A2>
00133     rc_reconfigurable_module(A1 a1, A2 a2);
00134 
00135     template<class A1, class A2, class A3>
00136     rc_reconfigurable_module(A1 a1, A2 a2, A3 a3);
00137 
00138     template<class A1, class A2, class A3, class A4>
00139     rc_reconfigurable_module(A1 a1, A2 a2, A3 a3, A4 a4);
00140 
00141     template<class A1, class A2, class A3, class A4, class A5>
00142     rc_reconfigurable_module(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5);
00143 
00144     template<class A1, class A2, class A3, class A4, class A5, class A6>
00145     rc_reconfigurable_module(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6);
00146 
00147     template<class A1, class A2, class A3, class A4,
00148             class A5, class A6, class A7>
00149     rc_reconfigurable_module(
00150         A1 a1, A2 a2, A3 a3, A4 a4,
00151         A5 a5, A6 a6, A7 a7);
00152 
00153     template<class A1, class A2, class A3, class A4,
00154             class A5, class A6, class A7, class A8>
00155     rc_reconfigurable_module(
00156         A1 a1, A2 a2, A3 a3, A4 a4,
00157         A5 a5, A6 a6, A7 a7, A8 a8);
00158 
00159     template<class A1, class A2, class A3, class A4, class A5,
00160             class A6, class A7, class A8, class A9>
00161     rc_reconfigurable_module(
00162         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
00163         A6 a6, A7 a7, A8 a8, A9 a9);
00164 
00165     template<class A1, class A2, class A3, class A4, class A5,
00166             class A6, class A7, class A8, class A9, class A10>
00167     rc_reconfigurable_module(
00168         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
00169         A6 a6, A7 a7, A8 a8, A9 a9, A10 a10);
00170 
00171 protected:
00172 
00183     inline sc_object* rc_find_object(
00184         const char* obj_name, const sc_object* rel_obj=NULL);
00185 
00186 /* next_trigger(..) redirects */
00187 
00191     inline void next_trigger()
00192         { rc_next_trigger(); }
00193 
00194     inline void next_trigger(const sc_event& e)
00195         { rc_next_trigger(e); }
00196 
00197     inline void next_trigger(sc_event_or_list& el)
00198         { rc_next_trigger(el); }
00199 
00200     inline void next_trigger(sc_event_and_list& el)
00201         { rc_next_trigger(el); }
00202 
00203     inline void next_trigger(const sc_time& t)
00204         { rc_next_trigger(t); }
00205 
00206     inline void next_trigger(double v, sc_time_unit tu)
00207         { rc_next_trigger(v, tu); }
00208 
00209     inline void next_trigger(const sc_time& t, const sc_event& e)
00210         { rc_next_trigger(t, e); }
00211 
00212     inline void next_trigger(double v, sc_time_unit tu, const sc_event& e)
00213         { rc_next_trigger(v, tu, e); }
00214 
00215     inline void next_trigger(const sc_time& t, sc_event_or_list& el)
00216         { rc_next_trigger(t, el); }
00217 
00218     inline void next_trigger(
00219         double v, sc_time_unit t, sc_event_or_list& el)
00220         { rc_next_trigger(v, t, el); }
00221 
00222     inline void next_trigger(const sc_time& t, sc_event_and_list& el)
00223         { rc_next_trigger(t, el); }
00224 
00225     inline void next_trigger(
00226         double v, sc_time_unit tu, sc_event_and_list& el)
00227         { rc_next_trigger(v, tu, el); }
00228 
00229 /* wait(..) redirects */
00230 
00234     inline void wait()
00235         { rc_wait(); }
00236 
00237     inline void wait(int n)
00238         { rc_wait(n); }
00239 
00240     inline void wait(const sc_event& e)
00241         { rc_wait(e); }
00242 
00243     inline void wait(sc_event_or_list& el)
00244         { rc_wait(el); }
00245 
00246     inline void wait(sc_event_and_list& el)
00247         { rc_wait(el); }
00248 
00249     inline void wait(const sc_time& t)
00250         { rc_wait(t); }
00251 
00252     inline void wait(double v, sc_time_unit tu)
00253         { rc_wait(v, tu); }
00254 
00255     inline void wait(const sc_time& t, const sc_event& e)
00256         { rc_wait(t, e); }
00257 
00258     inline void wait(double v, sc_time_unit tu, const sc_event& e)
00259         { rc_wait(v, tu, e); }
00260 
00261     inline void wait(const sc_time& t, sc_event_or_list& el)
00262         { rc_wait(t, el); }
00263 
00264     inline void wait(double v, sc_time_unit t, sc_event_or_list& el)
00265         { rc_wait(v, t, el); }
00266 
00267     inline void wait(const sc_time& t, sc_event_and_list& el)
00268         { rc_wait(t, el); }
00269 
00270     inline void wait(double v, sc_time_unit tu, sc_event_and_list& el)
00271         { rc_wait(v, tu, el); }
00272 };
00273 
00309 template<class Module>
00310 class rc_reconfigurable_module<Module, false>
00311     : public rc_reconfigurable,
00312       private internals::reconfigurable::begin_construction,
00313       public Module,
00314       virtual public rc_resettable
00315 {
00321     RC_STATIC_ASSERT_VALID_MODULE(Module);
00322 
00323 private:
00324     typedef typename internals::reconfigurable::begin_construction
00325         begin_construction;
00326 
00327 public:
00331     typedef Module module_type;
00332 
00333 public:
00337     rc_reconfigurable_module();
00338 
00342     rc_reconfigurable_module(sc_module_name module_name);
00343 
00344     template<class A1>
00345     rc_reconfigurable_module(A1 a1);
00346 
00347     template<class A1, class A2>
00348     rc_reconfigurable_module(A1 a1, A2 a2);
00349 
00350     template<class A1, class A2, class A3>
00351     rc_reconfigurable_module(A1 a1, A2 a2, A3 a3);
00352 
00353     template<class A1, class A2, class A3, class A4>
00354     rc_reconfigurable_module(A1 a1, A2 a2, A3 a3, A4 a4);
00355 
00356     template<class A1, class A2, class A3, class A4, class A5>
00357     rc_reconfigurable_module(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5);
00358 
00359     template<class A1, class A2, class A3, class A4, class A5, class A6>
00360     rc_reconfigurable_module(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6);
00361 
00362     template<class A1, class A2, class A3, class A4,
00363             class A5, class A6, class A7>
00364     rc_reconfigurable_module(
00365         A1 a1, A2 a2, A3 a3, A4 a4,
00366         A5 a5, A6 a6, A7 a7);
00367 
00368     template<class A1, class A2, class A3, class A4,
00369             class A5, class A6, class A7, class A8>
00370     rc_reconfigurable_module(
00371         A1 a1, A2 a2, A3 a3, A4 a4,
00372         A5 a5, A6 a6, A7 a7, A8 a8);
00373 
00374     template<class A1, class A2, class A3, class A4, class A5,
00375             class A6, class A7, class A8, class A9>
00376     rc_reconfigurable_module(
00377         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
00378         A6 a6, A7 a7, A8 a8, A9 a9);
00379 
00380     template<class A1, class A2, class A3, class A4, class A5,
00381             class A6, class A7, class A8, class A9, class A10>
00382     rc_reconfigurable_module(
00383         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5,
00384         A6 a6, A7 a7, A8 a8, A9 a9, A10 a10);
00385 
00386 protected:
00387     inline virtual void rc_on_reset() {}
00388 
00389     inline virtual void rc_on_init_resettable() {}
00390 
00401     inline sc_object* rc_find_object(
00402         const char* obj_name, const sc_object* rel_obj=NULL);
00403 
00404 /* next_trigger(..) redirects */
00405 
00409     inline void next_trigger()
00410         { rc_next_trigger(); }
00411 
00412     inline void next_trigger(const sc_event& e)
00413         { rc_next_trigger(e); }
00414 
00415     inline void next_trigger(sc_event_or_list& el)
00416         { rc_next_trigger(el); }
00417 
00418     inline void next_trigger(sc_event_and_list& el)
00419         { rc_next_trigger(el); }
00420 
00421     inline void next_trigger(const sc_time& t)
00422         { rc_next_trigger(t); }
00423 
00424     inline void next_trigger(double v, sc_time_unit tu)
00425         { rc_next_trigger(v, tu); }
00426 
00427     inline void next_trigger(const sc_time& t, const sc_event& e)
00428         { rc_next_trigger(t, e); }
00429 
00430     inline void next_trigger(double v, sc_time_unit tu, const sc_event& e)
00431         { rc_next_trigger(v, tu, e); }
00432 
00433     inline void next_trigger(const sc_time& t, sc_event_or_list& el)
00434         { rc_next_trigger(t, el); }
00435 
00436     inline void next_trigger(
00437         double v, sc_time_unit t, sc_event_or_list& el)
00438         { rc_next_trigger(v, t, el); }
00439 
00440     inline void next_trigger(const sc_time& t, sc_event_and_list& el)
00441         { rc_next_trigger(t, el); }
00442 
00443     inline void next_trigger(
00444         double v, sc_time_unit tu, sc_event_and_list& el)
00445         { rc_next_trigger(v, tu, el); }
00446 
00447 /* wait(..) redirects */
00448 
00452     inline void wait()
00453         { rc_wait(); }
00454 
00455     inline void wait(int n)
00456         { rc_wait(n); }
00457 
00458     inline void wait(const sc_event& e)
00459         { rc_wait(e); }
00460 
00461     inline void wait(sc_event_or_list& el)
00462         { rc_wait(el); }
00463 
00464     inline void wait(sc_event_and_list& el)
00465         { rc_wait(el); }
00466 
00467     inline void wait(const sc_time& t)
00468         { rc_wait(t); }
00469 
00470     inline void wait(double v, sc_time_unit tu)
00471         { rc_wait(v, tu); }
00472 
00473     inline void wait(const sc_time& t, const sc_event& e)
00474         { rc_wait(t, e); }
00475 
00476     inline void wait(double v, sc_time_unit tu, const sc_event& e)
00477         { rc_wait(v, tu, e); }
00478 
00479     inline void wait(const sc_time& t, sc_event_or_list& el)
00480         { rc_wait(t, el); }
00481 
00482     inline void wait(double v, sc_time_unit t, sc_event_or_list& el)
00483         { rc_wait(v, t, el); }
00484 
00485     inline void wait(const sc_time& t, sc_event_and_list& el)
00486         { rc_wait(t, el); }
00487 
00488     inline void wait(double v, sc_time_unit tu, sc_event_and_list& el)
00489         { rc_wait(v, tu, el); }
00490 };
00491 
00492 /* template code */
00493 
00494 // Module implements rc_resettable:
00495 
00496 template<class Module>
00497 rc_reconfigurable_module<Module, true>::rc_reconfigurable_module()
00498     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00499       module_type()
00500     { begin_construction::finish(static_cast<sc_module&>(*this)); }
00501 
00502 template<class Module>
00503 rc_reconfigurable_module<Module, true>::rc_reconfigurable_module(
00504     sc_module_name module_name)
00505     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00506       module_type(module_name)
00507     { begin_construction::finish(static_cast<sc_module&>(*this)); }
00508 
00509 template<class Module>
00510 template<class A1>
00511 rc_reconfigurable_module<Module, true>::rc_reconfigurable_module(A1 a1)
00512     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00513       module_type(a1)
00514     { begin_construction::finish(static_cast<sc_module&>(*this)); }
00515 
00516 template<class Module>
00517 template<class A1, class A2>
00518 rc_reconfigurable_module<Module, true>::rc_reconfigurable_module(
00519     A1 a1, A2 a2)
00520     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00521       module_type(a1, a2)
00522     { begin_construction::finish(static_cast<sc_module&>(*this)); }
00523 
00524 template<class Module>
00525 template<class A1, class A2, class A3>
00526 rc_reconfigurable_module<Module, true>::rc_reconfigurable_module(
00527     A1 a1, A2 a2, A3 a3)
00528     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00529       module_type(a1, a2, a3)
00530     { begin_construction::finish(static_cast<sc_module&>(*this)); }
00531 
00532 template<class Module>
00533 template<class A1, class A2, class A3, class A4>
00534 rc_reconfigurable_module<Module, true>::rc_reconfigurable_module(
00535     A1 a1, A2 a2, A3 a3, A4 a4)
00536     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00537       module_type(a1, a2, a3, a4)
00538     { begin_construction::finish(static_cast<sc_module&>(*this)); }
00539 
00540 template<class Module>
00541 template<class A1, class A2, class A3, class A4, class A5>
00542 rc_reconfigurable_module<Module, true>::rc_reconfigurable_module(
00543     A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
00544     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00545       module_type(a1, a2, a3, a4, a5)
00546     { begin_construction::finish(static_cast<sc_module&>(*this)); }
00547 
00548 template<class Module>
00549 template<class A1, class A2, class A3, class A4, class A5, class A6>
00550 rc_reconfigurable_module<Module, true>::rc_reconfigurable_module(
00551     A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
00552     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00553       module_type(a1, a2, a3, a4, a5, a6)
00554     { begin_construction::finish(static_cast<sc_module&>(*this)); }
00555 
00556 template<class Module>
00557 template<class A1, class A2, class A3, class A4,
00558         class A5, class A6, class A7>
00559 rc_reconfigurable_module<Module, true>::rc_reconfigurable_module(
00560     A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
00561     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00562       module_type(a1, a2, a3, a4, a5, a6, a7)
00563     { begin_construction::finish(static_cast<sc_module&>(*this)); }
00564 
00565 template<class Module>
00566 template<class A1, class A2, class A3, class A4,
00567         class A5, class A6, class A7, class A8>
00568 rc_reconfigurable_module<Module, true>::rc_reconfigurable_module(
00569     A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
00570     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00571       module_type(a1, a2, a3, a4, a5, a6, a7, a8)
00572     { begin_construction::finish(static_cast<sc_module&>(*this)); }
00573 
00574 template<class Module>
00575 template<class A1, class A2, class A3, class A4, class A5,
00576         class A6, class A7, class A8, class A9>
00577 rc_reconfigurable_module<Module, true>::rc_reconfigurable_module(
00578     A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
00579     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00580       module_type(a1, a2, a3, a4, a5, a6, a7, a8, a9)
00581     { begin_construction::finish(static_cast<sc_module&>(*this)); }
00582 
00583 template<class Module>
00584 template<class A1, class A2, class A3, class A4, class A5,
00585         class A6, class A7, class A8, class A9, class A10>
00586 rc_reconfigurable_module<Module, true>::rc_reconfigurable_module(
00587     A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
00588     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00589       module_type(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
00590     { begin_construction::finish(static_cast<sc_module&>(*this)); }
00591 
00592 /* inline code */
00593 
00594 template<class Module>
00595 inline
00596 sc_object* rc_reconfigurable_module<Module, true>::rc_find_object(
00597     const char* obj_name, const sc_object* rel_obj)
00598 {
00599     if (rel_obj == NULL) { rel_obj = this; }
00600     return ::ReChannel::rc_find_object(obj_name, rel_obj);
00601 }
00602 
00603 // Module does not implement rc_resettable:
00604 
00605 template<class Module>
00606 rc_reconfigurable_module<Module, false>::rc_reconfigurable_module()
00607     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00608       module_type(sc_module_name())
00609 {
00610     rc_reconfigurable::rc_register_resettable(*this);
00611     begin_construction::finish(static_cast<sc_module&>(*this));
00612 }
00613 
00614 template<class Module>
00615 rc_reconfigurable_module<Module, false>::rc_reconfigurable_module(
00616     sc_module_name module_name)
00617     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00618       module_type(module_name)
00619 {
00620     rc_reconfigurable::rc_register_resettable(*this);
00621     begin_construction::finish(static_cast<sc_module&>(*this));
00622 }
00623 
00624 template<class Module>
00625 template<class A1>
00626 rc_reconfigurable_module<Module, false>::rc_reconfigurable_module(A1 a1)
00627     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00628       module_type(a1)
00629 {
00630     rc_reconfigurable::rc_register_resettable(*this);
00631     begin_construction::finish(static_cast<sc_module&>(*this));
00632 }
00633 
00634 template<class Module>
00635 template<class A1, class A2>
00636 rc_reconfigurable_module<Module, false>::rc_reconfigurable_module(
00637     A1 a1, A2 a2)
00638     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00639       module_type(a1, a2)
00640 {
00641     rc_reconfigurable::rc_register_resettable(*this);
00642     begin_construction::finish(static_cast<sc_module&>(*this));
00643 }
00644 
00645 template<class Module>
00646 template<class A1, class A2, class A3>
00647 rc_reconfigurable_module<Module, false>::rc_reconfigurable_module(
00648     A1 a1, A2 a2, A3 a3)
00649     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00650       module_type(a1, a2, a3)
00651 {
00652     rc_reconfigurable::rc_register_resettable(*this);
00653     begin_construction::finish(static_cast<sc_module&>(*this));
00654 }
00655 
00656 template<class Module>
00657 template<class A1, class A2, class A3, class A4>
00658 rc_reconfigurable_module<Module, false>::rc_reconfigurable_module(
00659     A1 a1, A2 a2, A3 a3, A4 a4)
00660     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00661       module_type(a1, a2, a3, a4)
00662 {
00663     rc_reconfigurable::rc_register_resettable(*this);
00664     begin_construction::finish(static_cast<sc_module&>(*this));
00665 }
00666 
00667 template<class Module>
00668 template<class A1, class A2, class A3, class A4, class A5>
00669 rc_reconfigurable_module<Module, false>::rc_reconfigurable_module(
00670     A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
00671     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00672       module_type(a1, a2, a3, a4, a5)
00673 {
00674     rc_reconfigurable::rc_register_resettable(*this);
00675     begin_construction::finish(static_cast<sc_module&>(*this));
00676 }
00677 
00678 template<class Module>
00679 template<class A1, class A2, class A3, class A4, class A5, class A6>
00680 rc_reconfigurable_module<Module, false>::rc_reconfigurable_module(
00681     A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
00682     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00683       module_type(a1, a2, a3, a4, a5, a6)
00684 {
00685     rc_reconfigurable::rc_register_resettable(*this);
00686     begin_construction::finish(static_cast<sc_module&>(*this));
00687 }
00688 
00689 template<class Module>
00690 template<class A1, class A2, class A3, class A4,
00691         class A5, class A6, class A7>
00692 rc_reconfigurable_module<Module, false>::rc_reconfigurable_module(
00693     A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
00694     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00695       module_type(a1, a2, a3, a4, a5, a6, a7)
00696 {
00697     rc_reconfigurable::rc_register_resettable(*this);
00698     begin_construction::finish(static_cast<sc_module&>(*this));
00699 }
00700 
00701 template<class Module>
00702 template<class A1, class A2, class A3, class A4,
00703         class A5, class A6, class A7, class A8>
00704 rc_reconfigurable_module<Module, false>::rc_reconfigurable_module(
00705     A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
00706     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00707       module_type(a1, a2, a3, a4, a5, a6, a7, a8)
00708 {
00709     rc_reconfigurable::rc_register_resettable(*this);
00710     begin_construction::finish(static_cast<sc_module&>(*this));
00711 }
00712 
00713 template<class Module>
00714 template<class A1, class A2, class A3, class A4, class A5,
00715         class A6, class A7, class A8, class A9>
00716 rc_reconfigurable_module<Module, false>::rc_reconfigurable_module(
00717     A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
00718     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00719       module_type(a1, a2, a3, a4, a5, a6, a7, a8, a9)
00720 {
00721     rc_reconfigurable::rc_register_resettable(*this);
00722     begin_construction::finish(static_cast<sc_module&>(*this));
00723 }
00724 
00725 template<class Module>
00726 template<class A1, class A2, class A3, class A4, class A5,
00727         class A6, class A7, class A8, class A9, class A10>
00728 rc_reconfigurable_module<Module, false>::rc_reconfigurable_module(
00729     A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
00730     : begin_construction(static_cast<rc_reconfigurable&>(*this)),
00731       module_type(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
00732 {
00733     rc_reconfigurable::rc_register_resettable(*this);
00734     begin_construction::finish(static_cast<sc_module&>(*this));
00735 }
00736 
00737 /* inline code */
00738 
00739 template<class Module>
00740 inline
00741 sc_object* rc_reconfigurable_module<Module, false>::rc_find_object(
00742     const char* obj_name, const sc_object* rel_obj)
00743 {
00744     if (rel_obj == NULL) {
00745         rel_obj = this;
00746     }
00747     return ::ReChannel::rc_find_object(obj_name, rel_obj);
00748 }
00749 
00750 } // namespace ReChannel
00751 
00752 /* construction and helper macros */
00753 
00763 #define RC_RECONFIGURABLE_MODULE(reconf_module_name) \
00764     struct reconf_module_name \
00765         : public ::ReChannel::rc_reconfigurable_module<>
00766 
00776 #define RC_RECONFIGURABLE_CTOR(reconf_module_name) \
00777     RC_HAS_PROCESS(reconf_module_name); \
00778     reconf_module_name(const sc_module_name& name_) \
00779         : rc_reconfigurable_module<>(name_)
00780 
00790 #define RC_RECONFIGURABLE_MODULE_DERIVED(reconf_module_name, user_module_name) \
00791     struct reconf_module_name \
00792         : public ::ReChannel::rc_reconfigurable_module<user_module_name >
00793 
00803 #define RC_RECONFIGURABLE_CTOR_DERIVED(reconf_module_name, user_module_name) \
00804     RC_HAS_PROCESS(reconf_module_name); \
00805     reconf_module_name(const sc_module_name& name_) \
00806         : rc_reconfigurable_module<user_module_name >(name_)
00807 
00808 #endif // RC_RECONFIGURABLE_MODULE_H_
00809 
00810 //
00811 // $Id: rc_reconfigurable_module.h,v 1.16 2007/12/06 11:51:20 felke Exp $
00812 // $Source: /var/cvs/projekte/ReChannel-v2/src/ReChannel/core/rc_reconfigurable_module.h,v $
00813 //