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