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