00001
00031 #ifndef __adevs_wrapper_h_
00032 #define __adevs_wrapper_h_
00033 #include "adevs_models.h"
00034
00035 namespace adevs
00036 {
00054 template <typename ExternalType, typename InternalType, class T = double> class ModelWrapper:
00055 public Atomic<ExternalType,T>,
00056 public EventListener<InternalType,T>
00057 {
00058 public:
00064 ModelWrapper(Devs<InternalType,T>* model);
00073 virtual void translateInput(const Bag<ExternalType>& external_input,
00074 Bag<Event<InternalType,T> >& internal_input) = 0;
00083 virtual void translateOutput(const Bag<Event<InternalType,T> >& internal_output,
00084 Bag<ExternalType>& external_output) = 0;
00091 virtual void gc_input(Bag<Event<InternalType,T> >& g) = 0;
00093 Devs<InternalType,T>* getWrappedModel() { return model; }
00095 void delta_int();
00097 void delta_ext(T e, const Bag<ExternalType>& xb);
00099 void delta_conf(const Bag<ExternalType>& xb);
00101 void output_func(Bag<ExternalType>& yb);
00103 T ta();
00105 void outputEvent(Event<InternalType,T> y, T t);
00107 ~ModelWrapper();
00108 private:
00109 ModelWrapper(){}
00110 ModelWrapper(const ModelWrapper&){}
00111 void operator=(const ModelWrapper&){}
00112
00113 Bag<Event<InternalType,T> > input;
00114
00115 Bag<Event<InternalType,T> > output;
00116
00117 Devs<InternalType,T>* model;
00118
00119 Simulator<InternalType,T>* sim;
00120
00121 T tL;
00122 };
00123
00124 template <typename ExternalType, typename InternalType, class T>
00125 ModelWrapper<ExternalType,InternalType,T>::ModelWrapper(Devs<InternalType,T>* model):
00126 Atomic<ExternalType,T>(),
00127 EventListener<InternalType,T>(),
00128 model(model),
00129 tL(adevs_zero<T>())
00130 {
00131 sim = new Simulator<InternalType,T>(model);
00132 sim->addEventListener(this);
00133 }
00134
00135 template <typename ExternalType, typename InternalType, class T>
00136 void ModelWrapper<ExternalType,InternalType,T>::delta_int()
00137 {
00138
00139 tL = sim->nextEventTime();
00140
00141 sim->execNextEvent();
00142 }
00143
00144 template <typename ExternalType, typename InternalType, class T>
00145 void ModelWrapper<ExternalType,InternalType,T>::delta_ext(T e, const Bag<ExternalType>& xb)
00146 {
00147
00148 tL += e;
00149
00150 translateInput(xb,input);
00151
00152 sim->computeNextState(input,tL);
00153
00154 gc_input(input);
00155 input.clear();
00156 }
00157
00158 template <typename ExternalType, typename InternalType, class T>
00159 void ModelWrapper<ExternalType,InternalType,T>::delta_conf(const Bag<ExternalType>& xb)
00160 {
00161
00162 tL = sim->nextEventTime();
00163
00164 translateInput(xb,input);
00165
00166 sim->computeNextState(input,tL);
00167
00168 gc_input(input);
00169 input.clear();
00170 }
00171
00172 template <typename ExternalType, typename InternalType, class T>
00173 T ModelWrapper<ExternalType,InternalType,T>::ta()
00174 {
00175 if (sim->nextEventTime() < adevs_inf<T>()) return sim->nextEventTime()-tL;
00176 else return adevs_inf<T>();
00177 }
00178
00179 template <typename ExternalType, typename InternalType, class T>
00180 void ModelWrapper<ExternalType,InternalType,T>::output_func(Bag<ExternalType>& yb)
00181 {
00182
00183 sim->computeNextOutput();
00184
00185 translateOutput(output,yb);
00186
00187
00188 output.clear();
00189 }
00190
00191 template <typename ExternalType, typename InternalType, class T>
00192 void ModelWrapper<ExternalType,InternalType,T>::outputEvent(Event<InternalType,T> y, T t)
00193 {
00194
00195 output.insert(y);
00196 }
00197
00198 template <typename ExternalType, typename InternalType, class T>
00199 ModelWrapper<ExternalType,InternalType,T>::~ModelWrapper()
00200 {
00201 delete sim;
00202 delete model;
00203 }
00204
00205 }
00206
00207 #endif