Xcos MVC: use vector in the Controller
[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 class Block: public BaseObject
94 {
95 private:
96     friend class ::org_scilab_modules_scicos::Model;
97
98 private:
99     Block() : BaseObject(BLOCK), parentDiagram(0), interfaceFunction(), geometry(), parentBlock(0), portReference(0) {};
100     Block(const Block& o) : BaseObject(BLOCK), parentDiagram(o.parentDiagram), interfaceFunction(o.interfaceFunction), geometry(o.geometry), parentBlock(o.parentBlock), portReference(o.portReference) {};
101     ~Block() {}
102
103     const std::vector<ScicosID>& getChildren() const
104     {
105         return children;
106     }
107
108     void setChildren(const std::vector<ScicosID>& children)
109     {
110         this->children = children;
111     }
112
113     const std::vector<ScicosID>& getEin() const
114     {
115         return ein;
116     }
117
118     void setEin(const std::vector<ScicosID>& ein)
119     {
120         this->ein = ein;
121     }
122
123     const std::vector<ScicosID>& getEout() const
124     {
125         return eout;
126     }
127
128     void setEout(const std::vector<ScicosID>& eout)
129     {
130         this->eout = eout;
131     }
132
133     void getGeometry(std::vector<double>& v) const
134     {
135         geometry.fill(v);
136     }
137
138     update_status_t setGeometry(const std::vector<double>& v)
139     {
140         if (v.size() != 4)
141         {
142             return FAIL;
143         }
144
145         Geometry g = Geometry(v);
146         if (g == geometry)
147         {
148             return NO_CHANGES;
149         }
150
151         geometry = g;
152         return SUCCESS;
153     }
154
155     const std::vector<ScicosID>& getIn() const
156     {
157         return in;
158     }
159
160     void setIn(const std::vector<ScicosID>& in)
161     {
162         this->in = in;
163     }
164
165     const std::string& getInterfaceFunction() const
166     {
167         return interfaceFunction;
168     }
169
170     void setInterfaceFunction(const std::string& interfaceFunction)
171     {
172         this->interfaceFunction = interfaceFunction;
173     }
174
175     const std::vector<ScicosID>& getOut() const
176     {
177         return out;
178     }
179
180     void setOut(const std::vector<ScicosID>& out)
181     {
182         this->out = out;
183     }
184
185     const Parameter& getParameter() const
186     {
187         return parameter;
188     }
189
190     void setParameter(const Parameter& parameter)
191     {
192         this->parameter = parameter;
193     }
194
195     ScicosID getParentBlock() const
196     {
197         return parentBlock;
198     }
199
200     void setParentBlock(ScicosID parentBlock)
201     {
202         this->parentBlock = parentBlock;
203     }
204
205     ScicosID getParentDiagram() const
206     {
207         return parentDiagram;
208     }
209
210     void setParentDiagram(ScicosID parentDiagram)
211     {
212         this->parentDiagram = parentDiagram;
213     }
214
215     ScicosID getPortReference() const
216     {
217         return portReference;
218     }
219
220     void setPortReference(ScicosID portReference)
221     {
222         this->portReference = portReference;
223     }
224
225     const Descriptor& getSim() const
226     {
227         return sim;
228     }
229
230     void setSim(const Descriptor& sim)
231     {
232         this->sim = sim;
233     }
234
235     const std::string& getStyle() const
236     {
237         return style;
238     }
239
240     void setStyle(const std::string& style)
241     {
242         this->style = style;
243     }
244 private:
245     ScicosID parentDiagram;
246     std::string interfaceFunction;
247     Geometry geometry;
248     std::string style;
249
250     Descriptor sim;
251
252     std::vector<ScicosID> in;
253     std::vector<ScicosID> out;
254     std::vector<ScicosID> ein;
255     std::vector<ScicosID> eout;
256
257     Parameter parameter;
258     State state;
259
260     /**
261      * SuperBlock: the blocks, links and so on contained into this block
262      */
263     ScicosID parentBlock;
264     std::vector<ScicosID> children;
265
266     /**
267      * I/O Blocks: the corresponding parent port
268      */
269     ScicosID portReference;
270 };
271
272 } /* namespace model */
273 } /* namespace org_scilab_modules_scicos */
274
275 #endif /* BLOCK_HXX_ */