Xcos MVC: implement graphics.flip, theta, exprs, pin, pout
[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(), parentBlock(0), portReference(0) {};
124     Block(const Block& o) : BaseObject(BLOCK), parentDiagram(o.parentDiagram), interfaceFunction(o.interfaceFunction), geometry(o.geometry), parentBlock(o.parentBlock), portReference(o.portReference) {};
125     ~Block() {}
126
127     const std::vector<ScicosID>& getChildren() const
128     {
129         return children;
130     }
131
132     void setChildren(const std::vector<ScicosID>& children)
133     {
134         this->children = children;
135     }
136
137     const std::vector<ScicosID>& getEin() const
138     {
139         return ein;
140     }
141
142     void setEin(const std::vector<ScicosID>& ein)
143     {
144         this->ein = ein;
145     }
146
147     const std::vector<ScicosID>& getEout() const
148     {
149         return eout;
150     }
151
152     void setEout(const std::vector<ScicosID>& eout)
153     {
154         this->eout = eout;
155     }
156
157     void getGeometry(std::vector<double>& v) const
158     {
159         geometry.fill(v);
160     }
161
162     update_status_t setGeometry(const std::vector<double>& v)
163     {
164         if (v.size() != 4)
165         {
166             return FAIL;
167         }
168
169         Geometry g = Geometry(v);
170         if (g == geometry)
171         {
172             return NO_CHANGES;
173         }
174
175         geometry = g;
176         return SUCCESS;
177     }
178
179     void getAngle(std::vector<double>& data) const
180     {
181         angle.fill(data);
182     }
183
184     update_status_t setAngle(const std::vector<double>& data)
185     {
186         if (data.size() != 2)
187         {
188             return FAIL;
189         }
190
191         Angle a = Angle(data);
192         if (a == angle)
193         {
194             return NO_CHANGES;
195         }
196
197         angle = a;
198         return SUCCESS;
199     }
200
201     void getExprs(std::vector<std::string>& data) const
202     {
203         data = exprs;
204     }
205
206     update_status_t setExprs(const std::vector<std::string>& data)
207     {
208         if (data == exprs)
209         {
210             return NO_CHANGES;
211         }
212
213         exprs = data;
214         return SUCCESS;
215     }
216
217     const std::vector<ScicosID>& getIn() const
218     {
219         return in;
220     }
221
222     void setIn(const std::vector<ScicosID>& in)
223     {
224         this->in = in;
225     }
226
227     const std::string& getInterfaceFunction() const
228     {
229         return interfaceFunction;
230     }
231
232     void setInterfaceFunction(const std::string& interfaceFunction)
233     {
234         this->interfaceFunction = interfaceFunction;
235     }
236
237     const std::vector<ScicosID>& getOut() const
238     {
239         return out;
240     }
241
242     void setOut(const std::vector<ScicosID>& out)
243     {
244         this->out = out;
245     }
246
247     const Parameter& getParameter() const
248     {
249         return parameter;
250     }
251
252     void setParameter(const Parameter& parameter)
253     {
254         this->parameter = parameter;
255     }
256
257     ScicosID getParentBlock() const
258     {
259         return parentBlock;
260     }
261
262     void setParentBlock(ScicosID parentBlock)
263     {
264         this->parentBlock = parentBlock;
265     }
266
267     ScicosID getParentDiagram() const
268     {
269         return parentDiagram;
270     }
271
272     void setParentDiagram(ScicosID parentDiagram)
273     {
274         this->parentDiagram = parentDiagram;
275     }
276
277     ScicosID getPortReference() const
278     {
279         return portReference;
280     }
281
282     void setPortReference(ScicosID portReference)
283     {
284         this->portReference = portReference;
285     }
286
287     const Descriptor& getSim() const
288     {
289         return sim;
290     }
291
292     void setSim(const Descriptor& sim)
293     {
294         this->sim = sim;
295     }
296
297     const std::string& getStyle() const
298     {
299         return style;
300     }
301
302     void setStyle(const std::string& style)
303     {
304         this->style = style;
305     }
306 private:
307     ScicosID parentDiagram;
308     std::string interfaceFunction;
309     Geometry geometry;
310     Angle angle;
311     std::vector<std::string> exprs;
312     std::string style;
313
314     Descriptor sim;
315
316     std::vector<ScicosID> in;
317     std::vector<ScicosID> out;
318     std::vector<ScicosID> ein;
319     std::vector<ScicosID> eout;
320
321     Parameter parameter;
322     State state;
323
324     /**
325      * SuperBlock: the blocks, links and so on contained into this block
326      */
327     ScicosID parentBlock;
328     std::vector<ScicosID> children;
329
330     /**
331      * I/O Blocks: the corresponding parent port
332      */
333     ScicosID portReference;
334 };
335
336 } /* namespace model */
337 } /* namespace org_scilab_modules_scicos */
338
339 #endif /* BLOCK_HXX_ */