d21a556be0ad0488321831e3b33df94a0ea9eb6c
[scilab.git] / scilab / modules / scicos / src / cpp / model / Block.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-en.txt
10  *
11  */
12
13 #ifndef BLOCK_HXX_
14 #define BLOCK_HXX_
15
16 #include <cassert>
17 #include <string>
18 #include <vector>
19 #include <bitset>
20 #include <utility>
21
22 #include "Model.hxx"
23 #include "model/BaseObject.hxx"
24
25 namespace org_scilab_modules_scicos
26 {
27 namespace model
28 {
29
30 /**
31  * Scilab data that can be passed to the simulator and simulation functions.
32  *
33  * This used the raw scicos-sim encoding to avoid any conversion out of the model.
34  */
35 struct list_t
36 {
37     // re-use the scicos sim encoding
38     int n;
39     int* sz;
40     int* typ;
41     void** data;
42 };
43
44 struct Parameter
45 {
46     std::vector<double> rpar;
47     std::vector<int> ipar;
48     list_t opar;
49 };
50
51 struct State
52 {
53     std::vector<double> state;
54     std::vector<int> dstate;
55     list_t odstate;
56 };
57
58 /**
59  * Mask list for all possible block scheduling descriptor from the simulator point of view.
60  *
61  * Examples:
62  *  * CONST_m == 0
63  *  * SUMMATION == DEP_U
64  *  * CLR == DEP_T
65  *  * SWITCH_f == DEP_U & DEP_T
66  */
67 enum dep_ut_t
68 {
69     DEP_U       = 1 << 0, //!< y=f(u)
70     DEP_T       = 1 << 1, //!< y=f(x)
71 };
72
73 enum blocktype_t
74 {
75     BLOCKTYPE_C = 'c', //!< N/A ; dummy value used to represent a 'c' blocktype (eg. not 'd')
76     BLOCKTYPE_D = 'd', //!< N/A ; dummy value used to represent a 'd' blocktype (eg. not 'c')
77     BLOCKTYPE_H = 'h', //!< N/A ; used to represent blocks composed by blocks
78     BLOCKTYPE_L = 'l', //!< synchronization block ; ifthenelse and eselect
79     BLOCKTYPE_M = 'm', //!< memorization block ; see the Scicos original paper
80     BLOCKTYPE_X = 'x', //!< derivable block without state ; these blocks will be treated as if they contains a state.
81     BLOCKTYPE_Z = 'z', //!< zero-crossing block ; see the Scicos original paper.
82 };
83
84 struct Descriptor
85 {
86     std::string functionName;
87     char functionApi;
88
89     char dep_ut;            //!< dep_ut_t masked value
90     char blocktype;         //!< one of blocktype_t value
91 };
92
93 /*
94  * Flip and theta
95  */
96 struct Angle
97 {
98     bool flip;
99     double theta;
100
101     Angle() : flip(0), theta(0) {};
102     Angle(const Angle& a) : flip(a.flip), theta(a.theta) {};
103     Angle(const std::vector<double>& a) : flip((a[0] == 0) ? false : true), theta(a[1]) {};
104
105     void fill(std::vector<double>& a) const
106     {
107         a.resize(2);
108         a[0] = (flip == false) ? 0 : 1;
109         a[1] = theta;
110     }
111     bool operator==(const Angle& a) const
112     {
113         return flip == a.flip && theta == a.theta;
114     }
115 };
116
117 class Block: public BaseObject
118 {
119 private:
120     friend class ::org_scilab_modules_scicos::Model;
121
122 private:
123     Block() : BaseObject(BLOCK), parentDiagram(0), interfaceFunction(), geometry(),
124         angle(), exprs(), identifier(), style(), sim(), in(), out(), ein(), eout(),
125         parameter(), state(), parentBlock(0), children(), portReference(0) {};
126     Block(const Block& o) : BaseObject(BLOCK), parentDiagram(o.parentDiagram), interfaceFunction(o.interfaceFunction), geometry(o.geometry),
127         angle(o.angle), exprs(o.exprs), identifier(o.identifier), style(o.style), sim(o.sim), in(o.in), out(o.out), ein(o.ein), eout(o.eout),
128         parameter(o.parameter), state(o.state), parentBlock(o.parentBlock), children(o.children), portReference(o.portReference) {};
129     ~Block() {}
130
131     const std::vector<ScicosID>& getChildren() const
132     {
133         return children;
134     }
135
136     void setChildren(const std::vector<ScicosID>& children)
137     {
138         this->children = children;
139     }
140
141     void getGeometry(std::vector<double>& v) const
142     {
143         geometry.fill(v);
144     }
145
146     update_status_t setGeometry(const std::vector<double>& v)
147     {
148         if (v.size() != 4)
149         {
150             return FAIL;
151         }
152
153         Geometry g = Geometry(v);
154         if (g == geometry)
155         {
156             return NO_CHANGES;
157         }
158
159         geometry = g;
160         return SUCCESS;
161     }
162
163     void getAngle(std::vector<double>& data) const
164     {
165         angle.fill(data);
166     }
167
168     update_status_t setAngle(const std::vector<double>& data)
169     {
170         if (data.size() != 2)
171         {
172             return FAIL;
173         }
174
175         Angle a = Angle(data);
176         if (a == angle)
177         {
178             return NO_CHANGES;
179         }
180
181         angle = a;
182         return SUCCESS;
183     }
184
185     void getExprs(std::vector<std::string>& data) const
186     {
187         data = exprs;
188     }
189
190     update_status_t setExprs(const std::vector<std::string>& data)
191     {
192         if (data == exprs)
193         {
194             return NO_CHANGES;
195         }
196
197         exprs = data;
198         return SUCCESS;
199     }
200
201     void getIdentifier(std::string& data) const
202     {
203         data = identifier;
204     }
205
206     update_status_t setIdentifier(const std::string& data)
207     {
208         if (data == identifier)
209         {
210             return NO_CHANGES;
211         }
212
213         identifier = data;
214         return SUCCESS;
215     }
216
217     void getIn(std::vector<ScicosID>& v) const
218     {
219         v = in;
220     }
221
222     update_status_t setIn(const std::vector<ScicosID>& in)
223     {
224         if (in == this->in)
225         {
226             return NO_CHANGES;
227         }
228         this->in = in;
229         return SUCCESS;
230     }
231
232     const std::string& getInterfaceFunction() const
233     {
234         return interfaceFunction;
235     }
236
237     void setInterfaceFunction(const std::string& interfaceFunction)
238     {
239         this->interfaceFunction = interfaceFunction;
240     }
241
242     void getOut(std::vector<ScicosID>& v) const
243     {
244         v = out;
245     }
246
247     update_status_t setOut(const std::vector<ScicosID>& out)
248     {
249         if (out == this->out)
250         {
251             return NO_CHANGES;
252         }
253         this->out = out;
254         return SUCCESS;
255     }
256
257     void getEin(std::vector<ScicosID>& v) const
258     {
259         v = ein;
260     }
261
262     update_status_t setEin(const std::vector<ScicosID>& ein)
263     {
264         if (ein == this->ein)
265         {
266             return NO_CHANGES;
267         }
268         this->ein = ein;
269         return SUCCESS;
270     }
271
272     void getEout(std::vector<ScicosID>& v) const
273     {
274         v = eout;
275     }
276
277     update_status_t setEout(const std::vector<ScicosID>& eout)
278     {
279         if (eout == this->eout)
280         {
281             return NO_CHANGES;
282         }
283         this->eout = eout;
284         return SUCCESS;
285     }
286
287     const Parameter& getParameter() const
288     {
289         return parameter;
290     }
291
292     void setParameter(const Parameter& parameter)
293     {
294         this->parameter = parameter;
295     }
296
297     ScicosID getParentBlock() const
298     {
299         return parentBlock;
300     }
301
302     void setParentBlock(ScicosID parentBlock)
303     {
304         this->parentBlock = parentBlock;
305     }
306
307     ScicosID getParentDiagram() const
308     {
309         return parentDiagram;
310     }
311
312     void setParentDiagram(ScicosID parentDiagram)
313     {
314         this->parentDiagram = parentDiagram;
315     }
316
317     ScicosID getPortReference() const
318     {
319         return portReference;
320     }
321
322     void setPortReference(ScicosID portReference)
323     {
324         this->portReference = portReference;
325     }
326
327     const Descriptor& getSim() const
328     {
329         return sim;
330     }
331
332     void setSim(const Descriptor& sim)
333     {
334         this->sim = sim;
335     }
336
337     const std::string& getStyle() const
338     {
339         return style;
340     }
341
342     void setStyle(const std::string& style)
343     {
344         this->style = style;
345     }
346 private:
347     ScicosID parentDiagram;
348     std::string interfaceFunction;
349     Geometry geometry;
350     Angle angle;
351     std::vector<std::string> exprs;
352     std::string identifier;
353     std::string style;
354
355     Descriptor sim;
356
357     std::vector<ScicosID> in;
358     std::vector<ScicosID> out;
359     std::vector<ScicosID> ein;
360     std::vector<ScicosID> eout;
361
362     Parameter parameter;
363     State state;
364
365     /**
366      * SuperBlock: the blocks, links and so on contained into this block
367      */
368     ScicosID parentBlock;
369     std::vector<ScicosID> children;
370
371     /**
372      * I/O Blocks: the corresponding parent port
373      */
374     ScicosID portReference;
375 };
376
377 } /* namespace model */
378 } /* namespace org_scilab_modules_scicos */
379
380 #endif /* BLOCK_HXX_ */