02631cb49bcae931807f3af2889a5438803a77bf
[scilab.git] / scilab / modules / scicos / src / cpp / model / Diagram.hxx
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2014-2014 - Scilab Enterprises - Clement DAVID
4  *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  *
14  */
15
16 #ifndef DIAGRAM_HXX_
17 #define DIAGRAM_HXX_
18
19 #include <string>
20 #include <vector>
21
22 #include "utilities.hxx"
23 #include "Model.hxx"
24 #include "model/BaseObject.hxx"
25
26 namespace org_scilab_modules_scicos
27 {
28 namespace model
29 {
30
31 struct SimulationConfig
32 {
33     double final_time;          //!< Final simulation time.
34     double absolute_tolerance;  //!< Integrator absolute tolerance for the numerical solver.
35     double relative_tolerance;  //!< Integrator relative tolerance for the numerical solver.
36     double time_tolerance;      //!< Tolerance on time.
37     double delta_t;             //!< Maximum integration time interval.
38     double realtime_scale;      //!< Real-time scaling; the value 0 corresponds to no real-time scaling.
39     double solver;              //!< Current numerical solver.
40     double delta_h;             //!< Maximum step interval.
41
42     SimulationConfig() : final_time(100000), absolute_tolerance(1e-6), relative_tolerance(1e-6),
43         time_tolerance(1e-10), delta_t(final_time + 1), realtime_scale(0), solver(1), delta_h(0) {};
44
45     SimulationConfig(const SimulationConfig& p) :  final_time(p.final_time), absolute_tolerance(p.absolute_tolerance),
46         relative_tolerance(p.relative_tolerance), time_tolerance(p.time_tolerance), delta_t(p.delta_t),
47         realtime_scale(p.realtime_scale), solver(p.solver), delta_h(p.delta_h) {};
48
49     SimulationConfig(const std::vector<double>& p) : final_time(p[0]), absolute_tolerance(p[1]), relative_tolerance(p[2]),
50         time_tolerance(p[3]), delta_t(p[4]), realtime_scale(p[5]), solver(p[6]), delta_h(p[7]) {};
51
52     void fill(std::vector<double>& p) const
53     {
54         p.resize(8);
55         p[0] = final_time;
56         p[1] = absolute_tolerance;
57         p[2] = relative_tolerance;
58         p[3] = time_tolerance;
59         p[4] = delta_t;
60         p[5] = realtime_scale;
61         p[6] = solver;
62         p[7] = delta_h;
63     }
64     bool operator==(const SimulationConfig& p) const
65     {
66         return final_time == p.final_time && absolute_tolerance == p.absolute_tolerance &&
67                relative_tolerance == p.relative_tolerance && time_tolerance == p.time_tolerance &&
68                delta_t == p.delta_t && realtime_scale == p.realtime_scale && solver == p.solver && delta_h == p.delta_h;
69     }
70 };
71
72 class Diagram: public BaseObject
73 {
74 public:
75     Diagram() : BaseObject(DIAGRAM), m_title("Untitled"), m_path(), m_properties(), m_debugLevel(), m_context(), m_children(), m_version()
76     {
77         m_color = { -1, 1};
78     }
79
80     Diagram(const Diagram& o) : BaseObject(DIAGRAM), m_title(o.m_title), m_path(o.m_path), m_color(o.m_color), m_properties(o.m_properties),
81         m_debugLevel(o.m_debugLevel), m_context(o.m_context), m_children(o.m_children), m_version(o.m_version) {};
82     ~Diagram() = default;
83
84 private:
85     friend class ::org_scilab_modules_scicos::Model;
86
87     void getChildren(std::vector<ScicosID>& c) const
88     {
89         c = m_children;
90     }
91
92     update_status_t setChildren(const std::vector<ScicosID>& c)
93     {
94         if (c == m_children)
95         {
96             return NO_CHANGES;
97         }
98
99         m_children = c;
100         return SUCCESS;
101     }
102
103     void getContext(std::vector<std::string>& data) const
104     {
105         data = m_context;
106     }
107
108     update_status_t setContext(const std::vector<std::string>& data)
109     {
110         if (data == m_context)
111         {
112             return NO_CHANGES;
113         }
114
115         m_context = data;
116         return SUCCESS;
117     }
118
119     const std::vector<Datatype*>& getDatatypes() const
120     {
121         return m_datatypes;
122     }
123
124     void setDatatypes(const std::vector<Datatype*>& datatypes)
125     {
126         this->m_datatypes = datatypes;
127     }
128
129     void getProperties(std::vector<double>& v) const
130     {
131         m_properties.fill(v);
132     }
133
134     update_status_t setProperties(const std::vector<double>& v)
135     {
136         if (v.size() != 8)
137         {
138             return FAIL;
139         }
140
141         SimulationConfig p = SimulationConfig(v);
142         if (p == m_properties)
143         {
144             return NO_CHANGES;
145         }
146
147         m_properties = p;
148         return SUCCESS;
149     }
150
151     void getDebugLevel(int& data) const
152     {
153         data = m_debugLevel;
154     }
155
156     update_status_t setDebugLevel(const int& data)
157     {
158         if (data == m_debugLevel)
159         {
160             return NO_CHANGES;
161         }
162
163         m_debugLevel = data;
164         return SUCCESS;
165     }
166
167     void getTitle(std::string& data) const
168     {
169         data = m_title;
170     }
171
172     update_status_t setTitle(const std::string& data)
173     {
174         if (data == m_title)
175         {
176             return NO_CHANGES;
177         }
178
179         m_title = data;
180         return SUCCESS;
181     }
182
183     void getPath(std::string& data) const
184     {
185         data = m_path;
186     }
187
188     update_status_t setPath(const std::string& data)
189     {
190         if (data == m_path)
191         {
192             return NO_CHANGES;
193         }
194
195         m_path = data;
196         return SUCCESS;
197     }
198
199     void getColor(std::vector<int>& data) const
200     {
201         data = m_color;
202     }
203
204     update_status_t setColor(const std::vector<int>& data)
205     {
206         if (data == m_color)
207         {
208             return NO_CHANGES;
209         }
210
211         m_color = data;
212         return SUCCESS;
213     }
214
215     void getVersionNumber(std::string& data) const
216     {
217         data = m_version;
218     }
219
220     update_status_t setVersionNumber(const std::string& data)
221     {
222         if (data == m_version)
223         {
224             return NO_CHANGES;
225         }
226
227         m_version = data;
228         return SUCCESS;
229     }
230
231 private:
232     std::string m_title;
233     std::string m_path;
234     std::vector<int> m_color;
235     SimulationConfig m_properties;
236     int m_debugLevel;
237     std::vector<std::string> m_context;
238
239     std::vector<ScicosID> m_children;
240     std::vector<Datatype*> m_datatypes;
241
242     std::string m_version;
243 };
244
245 } /* namespace model */
246 } /* namespace org_scilab_modules_scicos */
247
248 #endif /* DIAGRAM_HXX_ */