Simplify QSS interface

src/artis-star/common/States.hpp

@@ -119,8 +119,8 @@ namespace artis {
     }
 }
 
-#define DECLARE_STATE(index, var)                                    \
-        this->state_(index, std::string(ESCAPEQUOTE(index)), var)
+#define DECLARE_STATE(W, index, var)                                    \
+        this->state_ < W >(index, std::string(ESCAPEQUOTE(index)), var)
 
 #define DECLARE_STATES(W, L) this-> template S_< W >(UNWRAP2 L)
 

src/artis-star/kernel/pdevs/Simulator.hpp

@@ -76,6 +76,8 @@ namespace artis {
 
             ~Simulator() { }
 
+            const Dynamics& dynamics() const { return _dynamics; }
+
             virtual void restore(const common::context::State<Time>& state)
             {
                 common::Simulator<Time>::restore(state);

src/artis-star/kernel/pdevs/qss/Derivative.hpp

@@ -57,7 +57,8 @@ namespace artis {
 
                 Derivative(const std::string& name, const Context<Time, Dyn, Parameters>& context)
                         :
-                        artis::pdevs::Dynamics<Time, Dyn, Parameters>(name, context)
+                        artis::pdevs::Dynamics<Time, Dyn, Parameters>(name, context),
+                        _external_number(0), _internal_number(0)
                 {
                     DECLARE_STATES(int,
                             ((STATE, &type::_state)));
@@ -73,6 +74,22 @@ namespace artis {
 
                 virtual ~Derivative() { }
 
+                int external(const std::string& name, double Dyn::* var)
+                {
+                    ++_external_number;
+                    this->state_(LAST_OUTPUT + _external_number + 1, name, var);
+                    this->input_port({IN + _external_number, name});
+                    return IN + _external_number;
+                }
+
+                void internal(const std::string& name, double Dyn::* var)
+                {
+                    assert(_internal_number == 0);
+
+                    ++_internal_number;
+                    this->state_(LAST_OUTPUT + 1, name, var);
+                }
+
                 virtual double compute() const = 0;
 
                 virtual void dconf(typename Time::type t, typename Time::type e,
@@ -98,11 +115,12 @@ namespace artis {
                                 IntegratorData data;
 
                                 event.data()(data);
-                                this->get(event.port_index() + 4).put(dynamic_cast<Dyn*>(this),
+                                this->get(event.port_index() + LAST_OUTPUT + 1).put(
+                                        dynamic_cast<Dyn*>(this),
                                         data.value);
                                 switch (_state) {
                                 case INIT:
-                                    if (_input_number == this->state_number() - 4) {
+                                    if (_input_number == this->state_number() - (LAST_OUTPUT + 1)) {
                                         _output_value = compute();
                                         _state = RESPONSE;
                                     }
@@ -173,6 +191,10 @@ namespace artis {
                 }
 
             private:
+                size_t _external_number;
+                size_t _internal_number;
+
+                // state
                 int _state;
                 unsigned int _input_number;
                 double _output_value;