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