CID1321282 fixed - Remove the default constructor
[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
83 private:
84     friend class ::org_scilab_modules_scicos::Model;
85
86     void getChildren(std::vector<ScicosID>& c) const
87     {
88         c = m_children;
89     }
90
91     update_status_t setChildren(const std::vector<ScicosID>& c)
92     {
93         if (c == m_children)
94         {
95             return NO_CHANGES;
96         }
97
98         m_children = c;
99         return SUCCESS;
100     }
101
102     void getContext(std::vector<std::string>& data) const
103     {
104         data = m_context;
105     }
106
107     update_status_t setContext(const std::vector<std::string>& data)
108     {
109         if (data == m_context)
110         {
111             return NO_CHANGES;
112         }
113
114         m_context = data;
115         return SUCCESS;
116     }
117
118     const std::vector<Datatype*>& getDatatypes() const
119     {
120         return m_datatypes;
121     }
122
123     void setDatatypes(const std::vector<Datatype*>& datatypes)
124     {
125         this->m_datatypes = datatypes;
126     }
127
128     void getProperties(std::vector<double>& v) const
129     {
130         m_properties.fill(v);
131     }
132
133     update_status_t setProperties(const std::vector<double>& v)
134     {
135         if (v.size() != 8)
136         {
137             return FAIL;
138         }
139
140         SimulationConfig p = SimulationConfig(v);
141         if (p == m_properties)
142         {
143             return NO_CHANGES;
144         }
145
146         m_properties = p;
147         return SUCCESS;
148     }
149
150     void getDebugLevel(int& data) const
151     {
152         data = m_debugLevel;
153     }
154
155     update_status_t setDebugLevel(const int& data)
156     {
157         if (data == m_debugLevel)
158         {
159             return NO_CHANGES;
160         }
161
162         m_debugLevel = data;
163         return SUCCESS;
164     }
165
166     void getTitle(std::string& data) const
167     {
168         data = m_title;
169     }
170
171     update_status_t setTitle(const std::string& data)
172     {
173         if (data == m_title)
174         {
175             return NO_CHANGES;
176         }
177
178         m_title = data;
179         return SUCCESS;
180     }
181
182     void getPath(std::string& data) const
183     {
184         data = m_path;
185     }
186
187     update_status_t setPath(const std::string& data)
188     {
189         if (data == m_path)
190         {
191             return NO_CHANGES;
192         }
193
194         m_path = data;
195         return SUCCESS;
196     }
197
198     void getColor(std::vector<int>& data) const
199     {
200         data = m_color;
201     }
202
203     update_status_t setColor(const std::vector<int>& data)
204     {
205         if (data == m_color)
206         {
207             return NO_CHANGES;
208         }
209
210         m_color = data;
211         return SUCCESS;
212     }
213
214     void getVersionNumber(std::string& data) const
215     {
216         data = m_version;
217     }
218
219     update_status_t setVersionNumber(const std::string& data)
220     {
221         if (data == m_version)
222         {
223             return NO_CHANGES;
224         }
225
226         m_version = data;
227         return SUCCESS;
228     }
229
230 private:
231     std::string m_title;
232     std::string m_path;
233     std::vector<int> m_color;
234     SimulationConfig m_properties;
235     int m_debugLevel;
236     std::vector<std::string> m_context;
237
238     std::vector<ScicosID> m_children;
239     std::vector<Datatype*> m_datatypes;
240
241     std::string m_version;
242 };
243
244 } /* namespace model */
245 } /* namespace org_scilab_modules_scicos */
246
247 #endif /* DIAGRAM_HXX_ */