fix windows compilation after https://codereview.scilab.org/#/c/17289
[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.1-en.txt
10  *
11  */
12
13 #ifndef BLOCK_HXX_
14 #define BLOCK_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 Parameter
29 {
30     std::vector<double> rpar;
31     std::vector<int> ipar;
32     std::vector<double> opar;
33
34     // opar default value is an empty list encoded by var2vec()
35     Parameter() : rpar(), ipar()
36     {
37         opar = {22, 0};
38     }
39 };
40
41 struct State
42 {
43     std::vector<double> state;
44     std::vector<double> dstate;
45     std::vector<double> odstate;
46
47     // odstate default value is an empty list encoded by var2vec()
48     State() : state(), dstate()
49     {
50         odstate = {22, 0};
51     }
52 };
53
54 /**
55  * Mask list for all possible block scheduling descriptor from the simulator point of view.
56  *
57  * Examples:
58  *  * CONST_m == 0
59  *  * SUMMATION == DEP_U
60  *  * CLR == DEP_T
61  *  * SWITCH_f == DEP_U | DEP_T
62  */
63 enum dep_ut_t
64 {
65     DEP_U       = 1 << 0, //!< y=f(u)
66     DEP_T       = 1 << 1, //!< y=f(x)
67 };
68
69 enum blocktype_t
70 {
71     BLOCKTYPE_C = 'c', //!< N/A ; dummy value used to represent a 'c' blocktype (eg. not 'd')
72     BLOCKTYPE_D = 'd', //!< N/A ; dummy value used to represent a 'd' blocktype (eg. not 'c')
73     BLOCKTYPE_H = 'h', //!< N/A ; used to represent blocks composed by blocks
74     BLOCKTYPE_L = 'l', //!< synchronization block ; ifthenelse and eselect
75     BLOCKTYPE_M = 'm', //!< memorization block ; see the Scicos original paper
76     BLOCKTYPE_X = 'x', //!< derivable block without state ; these blocks will be treated as if they contain a state.
77     BLOCKTYPE_Z = 'z', //!< zero-crossing block ; see the Scicos original paper.
78 };
79
80 struct Descriptor
81 {
82     std::string functionName;
83     int functionApi;
84
85     char dep_ut;            //!< dep_ut_t masked value
86     char blocktype;         //!< one of blocktype_t value
87
88     Descriptor() : functionName(), functionApi(0), dep_ut(0), blocktype(BLOCKTYPE_C) {}
89 };
90
91 /*
92  * Flip and theta
93  */
94 struct Angle
95 {
96     bool flip;
97     double theta;
98
99     Angle() : flip(true), theta(0) {};
100     Angle(const Angle& a) : flip(a.flip), theta(a.theta) {};
101     Angle(const std::vector<double>& a) : flip((a[0] == 0) ? false : true), theta(a[1]) {};
102
103     void fill(std::vector<double>& a) const
104     {
105         a.resize(2);
106         a[0] = (flip == false) ? 0 : 1;
107         a[1] = theta;
108     }
109     bool operator==(const Angle& a) const
110     {
111         return flip == a.flip && theta == a.theta;
112     }
113 };
114
115 class Block: public BaseObject
116 {
117 public:
118     Block() : BaseObject(BLOCK), m_parentDiagram(ScicosID()), m_interfaceFunction(), m_geometry(), m_angle(),
119         m_label(), m_style(), m_equations(), m_uid(), m_sim(), m_in(), m_out(), m_ein(), m_eout(),
120         m_parameter(), m_state(), m_parentBlock(ScicosID()), m_children(), m_portReference(ScicosID())
121     {
122         m_exprs = {12, 2, 0, 0, 0};
123         m_nmode = {0};
124         m_nzcross = {0};
125         m_childrenColor = { -1, 1};
126     }
127     Block(const Block& o) : BaseObject(BLOCK), m_parentDiagram(o.m_parentDiagram), m_interfaceFunction(o.m_interfaceFunction), m_geometry(o.m_geometry),
128         m_angle(o.m_angle), m_exprs(o.m_exprs), m_label(o.m_label), m_style(o.m_style), m_nzcross(o.m_nzcross), m_nmode(o.m_nmode), m_equations(o.m_equations), m_uid(o.m_uid),
129         m_sim(o.m_sim), m_in(o.m_in), m_out(o.m_out), m_ein(o.m_ein), m_eout(o.m_eout), m_parameter(o.m_parameter), m_state(o.m_state), m_parentBlock(o.m_parentBlock),
130         m_children(o.m_children), m_childrenColor(o.m_childrenColor), m_portReference(o.m_portReference) {}
131     ~Block() = default;
132
133 private:
134     friend class ::org_scilab_modules_scicos::Model;
135
136     void getChildren(std::vector<ScicosID>& v) const
137     {
138         v = this->m_children;
139     }
140
141     update_status_t setChildren(const std::vector<ScicosID>& children)
142     {
143         if (children == this->m_children)
144         {
145             return NO_CHANGES;
146         }
147
148         this->m_children = children;
149         return SUCCESS;
150     }
151
152     void getChildrenColor(std::vector<int>& data) const
153     {
154         data = this->m_childrenColor;
155     }
156
157     update_status_t setChildrenColor(const std::vector<int>& data)
158     {
159         if (data == this->m_childrenColor)
160         {
161             return NO_CHANGES;
162         }
163
164         this->m_childrenColor = data;
165         return SUCCESS;
166     }
167
168     void getGeometry(std::vector<double>& v) const
169     {
170         m_geometry.fill(v);
171     }
172
173     update_status_t setGeometry(const std::vector<double>& v)
174     {
175         if (v.size() != 4)
176         {
177             return FAIL;
178         }
179
180         Geometry g = Geometry(v);
181         if (g == m_geometry)
182         {
183             return NO_CHANGES;
184         }
185
186         m_geometry = g;
187         return SUCCESS;
188     }
189
190     void getAngle(std::vector<double>& data) const
191     {
192         m_angle.fill(data);
193     }
194
195     update_status_t setAngle(const std::vector<double>& data)
196     {
197         if (data.size() != 2)
198         {
199             return FAIL;
200         }
201
202         Angle a = Angle(data);
203         if (a == m_angle)
204         {
205             return NO_CHANGES;
206         }
207
208         m_angle = a;
209         return SUCCESS;
210     }
211
212     void getExprs(std::vector<double>& data) const
213     {
214         data = m_exprs;
215     }
216
217     update_status_t setExprs(const std::vector<double>& data)
218     {
219         if (data == m_exprs)
220         {
221             return NO_CHANGES;
222         }
223
224         m_exprs = data;
225         return SUCCESS;
226     }
227
228     void getLabel(std::string& data) const
229     {
230         data = m_label;
231     }
232
233     update_status_t setLabel(const std::string& data)
234     {
235         if (data == m_label)
236         {
237             return NO_CHANGES;
238         }
239
240         m_label = data;
241         return SUCCESS;
242     }
243
244     void getIn(std::vector<ScicosID>& v) const
245     {
246         v = m_in;
247     }
248
249     update_status_t setIn(const std::vector<ScicosID>& in)
250     {
251         if (in == this->m_in)
252         {
253             return NO_CHANGES;
254         }
255
256         this->m_in = in;
257         return SUCCESS;
258     }
259
260     void getInterfaceFunction(std::string& fun) const
261     {
262         fun = m_interfaceFunction;
263     }
264
265     update_status_t setInterfaceFunction(const std::string& fun)
266     {
267         if (fun == m_interfaceFunction)
268         {
269             return NO_CHANGES;
270         }
271
272         m_interfaceFunction = fun;
273         return SUCCESS;
274     }
275
276     void getOut(std::vector<ScicosID>& v) const
277     {
278         v = m_out;
279     }
280
281     update_status_t setOut(const std::vector<ScicosID>& out)
282     {
283         if (out == this->m_out)
284         {
285             return NO_CHANGES;
286         }
287
288         this->m_out = out;
289         return SUCCESS;
290     }
291
292     void getEin(std::vector<ScicosID>& v) const
293     {
294         v = m_ein;
295     }
296
297     update_status_t setEin(const std::vector<ScicosID>& ein)
298     {
299         if (ein == this->m_ein)
300         {
301             return NO_CHANGES;
302         }
303
304         this->m_ein = ein;
305         return SUCCESS;
306     }
307
308     void getEout(std::vector<ScicosID>& v) const
309     {
310         v = m_eout;
311     }
312
313     update_status_t setEout(const std::vector<ScicosID>& eout)
314     {
315         if (eout == this->m_eout)
316         {
317             return NO_CHANGES;
318         }
319
320         this->m_eout = eout;
321         return SUCCESS;
322     }
323
324     const Parameter& getParameter() const
325     {
326         return m_parameter;
327     }
328
329     void setParameter(const Parameter& parameter)
330     {
331         this->m_parameter = parameter;
332     }
333
334     void getParentBlock(ScicosID& v) const
335     {
336         v = m_parentBlock;
337     }
338
339     update_status_t setParentBlock(ScicosID parentBlock)
340     {
341         if (parentBlock == this->m_parentBlock)
342         {
343             return NO_CHANGES;
344         }
345
346         this->m_parentBlock = parentBlock;
347         return SUCCESS;
348     }
349
350     void getParentDiagram(ScicosID& v) const
351     {
352         v = m_parentDiagram;
353     }
354
355     update_status_t setParentDiagram(const ScicosID v)
356     {
357         if (v == m_parentDiagram)
358         {
359             return NO_CHANGES;
360         }
361
362         m_parentDiagram = v;
363         return SUCCESS;
364     }
365
366     void getPortReference(ScicosID& v) const
367     {
368         v = m_portReference;
369     }
370
371     update_status_t setPortReference(const ScicosID v)
372     {
373         if (v == m_portReference)
374         {
375             return NO_CHANGES;
376         }
377
378         m_portReference = v;
379         return SUCCESS;
380     }
381
382     const Descriptor& getSim() const
383     {
384         return m_sim;
385     }
386
387     void setSim(const Descriptor& sim)
388     {
389         this->m_sim = sim;
390     }
391
392     void getStyle(std::string& data) const
393     {
394         data = m_style;
395     }
396
397     update_status_t setStyle(const std::string& data)
398     {
399         if (data == m_style)
400         {
401             return NO_CHANGES;
402         }
403
404         m_style = data;
405         return SUCCESS;
406     }
407
408     void getNZcross(std::vector<int>& data) const
409     {
410         data = m_nzcross;
411     }
412
413     update_status_t setNZcross(const std::vector<int>& data)
414     {
415         if (data == m_nzcross)
416         {
417             return NO_CHANGES;
418         }
419
420         m_nzcross = data;
421         return SUCCESS;
422     }
423
424     void getNMode(std::vector<int>& data) const
425     {
426         data = m_nmode;
427     }
428
429     update_status_t setNMode(const std::vector<int>& data)
430     {
431         if (data == m_nmode)
432         {
433             return NO_CHANGES;
434         }
435
436         m_nmode = data;
437         return SUCCESS;
438     }
439
440     void getEquations(std::vector<std::string>& data) const
441     {
442         data = m_equations;
443     }
444
445     update_status_t setEquations(const std::vector<std::string>& data)
446     {
447         if (data == m_equations)
448         {
449             return NO_CHANGES;
450         }
451
452         m_equations = data;
453         return SUCCESS;
454     }
455
456     void getUID(std::string& data) const
457     {
458         data = m_uid;
459     }
460
461     update_status_t setUID(const std::string& data)
462     {
463         if (data == m_uid)
464         {
465             return NO_CHANGES;
466         }
467
468         m_uid = data;
469         return SUCCESS;
470     }
471
472     void getRpar(std::vector<double>& data) const
473     {
474         data = m_parameter.rpar;
475     }
476
477     update_status_t setRpar(const std::vector<double>& data)
478     {
479         if (data == m_parameter.rpar)
480         {
481             return NO_CHANGES;
482         }
483
484         m_parameter.rpar = data;
485         return SUCCESS;
486     }
487
488     void getIpar(std::vector<int>& data) const
489     {
490         data = m_parameter.ipar;
491     }
492
493     update_status_t setIpar(const std::vector<int>& data)
494     {
495         if (data == m_parameter.ipar)
496         {
497             return NO_CHANGES;
498         }
499
500         m_parameter.ipar = data;
501         return SUCCESS;
502     }
503
504     void getOpar(std::vector<double>& data) const
505     {
506         data = m_parameter.opar;
507     }
508
509     update_status_t setOpar(const std::vector<double>& data)
510     {
511         if (data == m_parameter.opar)
512         {
513             return NO_CHANGES;
514         }
515
516         m_parameter.opar = data;
517         return SUCCESS;
518     }
519
520     void getSimFunctionName(std::string& data) const
521     {
522         data = m_sim.functionName;
523     }
524
525     update_status_t setSimFunctionName(const std::string& data)
526     {
527         if (data == m_sim.functionName)
528         {
529             return NO_CHANGES;
530         }
531
532         m_sim.functionName = data;
533         return SUCCESS;
534     }
535
536     void getSimFunctionApi(int& data) const
537     {
538         data = m_sim.functionApi;
539     }
540
541     update_status_t setSimFunctionApi(const int data)
542     {
543         if (data == m_sim.functionApi)
544         {
545             return NO_CHANGES;
546         }
547
548         m_sim.functionApi = data;
549         return SUCCESS;
550     }
551
552     void getSimBlocktype(std::string& data) const
553     {
554         data = std::string(1, m_sim.blocktype);
555     }
556
557     update_status_t setSimBlocktype(const std::string data)
558     {
559         if (data.size() != 1)
560         {
561             return FAIL;
562         }
563
564         char c = *(data.c_str());
565
566         if (c == m_sim.blocktype)
567         {
568             return NO_CHANGES;
569         }
570
571         switch (c)
572         {
573             case BLOCKTYPE_C:
574             case BLOCKTYPE_D:
575             case BLOCKTYPE_H:
576             case BLOCKTYPE_L:
577             case BLOCKTYPE_M:
578             case BLOCKTYPE_X:
579             case BLOCKTYPE_Z:
580                 m_sim.blocktype = c;
581                 return SUCCESS;
582             default:
583                 return FAIL;
584         }
585     }
586
587     void getSimDepUT(std::vector<int>& data) const
588     {
589         data.resize(2, 0);
590         switch (m_sim.dep_ut)
591         {
592             case DEP_U & DEP_T:
593                 // data is already set to [0 0] here.
594                 break;
595             case DEP_U:
596                 data[0] = 1;
597                 break;
598             case DEP_T:
599                 data[1] = 1;
600                 break;
601             case DEP_U | DEP_T:
602                 data[0] = 1;
603                 data[1] = 1;
604                 break;
605             default:
606                 break;
607         }
608     }
609
610     update_status_t setSimDepUT(const std::vector<int>& data)
611     {
612         if (data.size() != 2)
613         {
614             return FAIL;
615         }
616
617         int dep = DEP_U & DEP_T;
618         if (data[0])
619         {
620             if (data[1])
621             {
622                 dep = DEP_U | DEP_T;
623             }
624             else
625             {
626                 dep = DEP_U;
627             }
628         }
629         else if (data[1])
630         {
631             dep = DEP_T;
632         }
633
634         if (dep == m_sim.dep_ut)
635         {
636             return NO_CHANGES;
637         }
638
639         m_sim.dep_ut = dep;
640         return SUCCESS;
641     }
642
643     void getState(std::vector<double>& data) const
644     {
645         data = m_state.state;
646     }
647
648     update_status_t setState(const std::vector<double>& data)
649     {
650         if (data == m_state.state)
651         {
652             return NO_CHANGES;
653         }
654
655         m_state.state = data;
656         return SUCCESS;
657     }
658
659     void getDState(std::vector<double>& data) const
660     {
661         data = m_state.dstate;
662     }
663
664     update_status_t setDState(const std::vector<double>& data)
665     {
666         if (data == m_state.dstate)
667         {
668             return NO_CHANGES;
669         }
670
671         m_state.dstate = data;
672         return SUCCESS;
673     }
674
675     void getODState(std::vector<double>& data) const
676     {
677         data = m_state.odstate;
678     }
679
680     update_status_t setODState(const std::vector<double>& data)
681     {
682         if (data == m_state.odstate)
683         {
684             return NO_CHANGES;
685         }
686
687         m_state.odstate = data;
688         return SUCCESS;
689     }
690
691 private:
692     ScicosID m_parentDiagram;
693     std::string m_interfaceFunction;
694     Geometry m_geometry;
695     Angle m_angle;
696     std::vector<double> m_exprs;
697     std::string m_label;
698     std::string m_style;
699     std::vector<int> m_nzcross;
700     std::vector<int> m_nmode;
701     std::vector<std::string> m_equations;
702     std::string m_uid;
703
704     Descriptor m_sim;
705
706     std::vector<ScicosID> m_in;
707     std::vector<ScicosID> m_out;
708     std::vector<ScicosID> m_ein;
709     std::vector<ScicosID> m_eout;
710
711     Parameter m_parameter;
712     State m_state;
713
714     /**
715      * SuperBlock: the blocks, links and so on contained into this block
716      */
717     ScicosID m_parentBlock;
718     std::vector<ScicosID> m_children;
719     std::vector<int> m_childrenColor;
720
721     /**
722      * I/O Blocks: the corresponding parent port
723      */
724     ScicosID m_portReference;
725 };
726
727 } /* namespace model */
728 } /* namespace org_scilab_modules_scicos */
729
730 #endif /* BLOCK_HXX_ */