* Bug 16365 fixed: median(m,'r'|'c') was wrong after 5dc990
[scilab.git] / scilab / modules / scicos / src / cpp / Model_getObjectProperties.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2014-2016 - Scilab Enterprises - Clement DAVID
4  * Copyright (C) 2017 - ESI Group - Clement DAVID
5  *
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  *
15  */
16
17 #include <string>
18 #include <vector>
19
20 #include "Model.hxx"
21 #include "utilities.hxx"
22
23 #include "model/BaseObject.hxx"
24 #include "model/Annotation.hxx"
25 #include "model/Diagram.hxx"
26 #include "model/Block.hxx"
27 #include "model/Link.hxx"
28 #include "model/Port.hxx"
29
30 extern "C" {
31 #include "sci_types.h"
32 }
33
34 namespace org_scilab_modules_scicos
35 {
36
37 bool Model::getObjectProperty(model::BaseObject* object, object_properties_t p, double& v)  const
38 {
39     model::BaseObject* baseObject = object;
40     if (baseObject == nullptr)
41     {
42         return false;
43     }
44     kind_t k = object->kind();
45
46     if (k == ANNOTATION)
47     {
48         switch (p)
49         {
50             default:
51                 break;
52         }
53     }
54     else if (k == BLOCK)
55     {
56         switch (p)
57         {
58             default:
59                 break;
60         }
61     }
62     else if (k == DIAGRAM)
63     {
64         switch (p)
65         {
66             default:
67                 break;
68         }
69     }
70     else if (k == LINK)
71     {
72         switch (p)
73         {
74             default:
75                 break;
76         }
77     }
78     else if (k == PORT)
79     {
80         model::Port* o = static_cast<model::Port*>(baseObject);
81         switch (p)
82         {
83             case FIRING:
84                 o->getFiring(v);
85                 return true;
86             default:
87                 break;
88         }
89     }
90     return false;
91 }
92
93 bool Model::getObjectProperty(model::BaseObject* object, object_properties_t p, int& v) const
94 {
95     model::BaseObject* baseObject = object;
96     if (baseObject == nullptr)
97     {
98         return false;
99     }
100     kind_t k = object->kind();
101
102     if (k == ANNOTATION)
103     {
104         switch (p)
105         {
106             default:
107                 break;
108         }
109     }
110     else if (k == BLOCK)
111     {
112         model::Block* o = static_cast<model::Block*>(baseObject);
113         switch (p)
114         {
115             case SIM_FUNCTION_API:
116                 o->getSimFunctionApi(v);
117                 return true;
118             default:
119                 break;
120         }
121     }
122     else if (k == DIAGRAM)
123     {
124         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
125         switch (p)
126         {
127             case DEBUG_LEVEL:
128                 o->getDebugLevel(v);
129                 return true;
130             default:
131                 break;
132         }
133     }
134     else if (k == LINK)
135     {
136         model::Link* o = static_cast<model::Link*>(baseObject);
137         switch (p)
138         {
139             case COLOR:
140                 o->getColor(v);
141                 return true;
142             case KIND:
143                 o->getKind(v);
144                 return true;
145             default:
146                 break;
147         }
148     }
149     else if (k == PORT)
150     {
151         model::Port* o = static_cast<model::Port*>(baseObject);
152         switch (p)
153         {
154             case PORT_KIND:
155                 o->getKind(v);
156                 return true;
157             default:
158                 break;
159         }
160     }
161     return false;
162 }
163
164 bool Model::getObjectProperty(model::BaseObject* object, object_properties_t p, bool& v) const
165 {
166     model::BaseObject* baseObject = object;
167     if (baseObject == nullptr)
168     {
169         return false;
170     }
171     kind_t k = object->kind();
172
173     if (k == ANNOTATION)
174     {
175         switch (p)
176         {
177             default:
178                 break;
179         }
180     }
181     else if (k == BLOCK)
182     {
183         switch (p)
184         {
185             default:
186                 break;
187         }
188     }
189     else if (k == DIAGRAM)
190     {
191         switch (p)
192         {
193             default:
194                 break;
195         }
196     }
197     else if (k == LINK)
198     {
199         switch (p)
200         {
201             default:
202                 break;
203         }
204     }
205     else if (k == PORT)
206     {
207         model::Port* o = static_cast<model::Port*>(baseObject);
208         switch (p)
209         {
210             case IMPLICIT:
211                 o->getImplicit(v);
212                 return true;
213             default:
214                 break;
215         }
216     }
217     return false;
218 }
219
220 bool Model::getObjectProperty(model::BaseObject* object, object_properties_t p, std::string& v) const
221 {
222     model::BaseObject* baseObject = object;
223     if (baseObject == nullptr)
224     {
225         return false;
226     }
227     kind_t k = object->kind();
228
229     if (k == ANNOTATION)
230     {
231         model::Annotation* o = static_cast<model::Annotation*>(baseObject);
232         switch (p)
233         {
234             case DESCRIPTION:
235                 o->getDescription(v);
236                 return true;
237             case FONT:
238                 o->getFont(v);
239                 return true;
240             case FONT_SIZE:
241                 o->getFontSize(v);
242                 return true;
243             case STYLE:
244                 o->getStyle(v);
245                 return true;
246             case UID:
247                 o->getUID(v);
248                 return true;
249             default:
250                 break;
251         }
252     }
253     else if (k == BLOCK)
254     {
255         model::Block* o = static_cast<model::Block*>(baseObject);
256         switch (p)
257         {
258             case INTERFACE_FUNCTION:
259                 o->getInterfaceFunction(v);
260                 return true;
261             case SIM_FUNCTION_NAME:
262                 o->getSimFunctionName(v);
263                 return true;
264             case SIM_BLOCKTYPE:
265                 o->getSimBlocktype(v);
266                 return true;
267             case STYLE:
268                 o->getStyle(v);
269                 return true;
270             case DESCRIPTION:
271                 o->getDescription(v);
272                 return true;
273             case UID:
274                 o->getUID(v);
275                 return true;
276             default:
277                 break;
278         }
279     }
280     else if (k == DIAGRAM)
281     {
282         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
283         switch (p)
284         {
285             case TITLE:
286                 o->getTitle(v);
287                 return true;
288             case PATH:
289                 o->getPath(v);
290                 return true;
291             case VERSION_NUMBER:
292                 o->getVersionNumber(v);
293                 return true;
294             default:
295                 break;
296         }
297     }
298     else if (k == LINK)
299     {
300         model::Link* o = static_cast<model::Link*>(baseObject);
301         switch (p)
302         {
303             case DESCRIPTION:
304                 o->getDescription(v);
305                 return true;
306             case STYLE:
307                 o->getStyle(v);
308                 return true;
309             case UID:
310                 o->getUID(v);
311                 return true;
312             default:
313                 break;
314         }
315     }
316     else if (k == PORT)
317     {
318         model::Port* o = static_cast<model::Port*>(baseObject);
319         switch (p)
320         {
321             case STYLE:
322                 o->getStyle(v);
323                 return true;
324             case LABEL:
325                 o->getLabel(v);
326                 return true;
327             case UID:
328                 o->getUID(v);
329                 return true;
330             default:
331                 break;
332         }
333     }
334     return false;
335 }
336
337 bool Model::getObjectProperty(model::BaseObject* object, object_properties_t p, ScicosID& v) const
338 {
339     model::BaseObject* baseObject = object;
340     if (baseObject == nullptr)
341     {
342         return false;
343     }
344     kind_t k = object->kind();
345
346     if (k == ANNOTATION)
347     {
348         model::Annotation* o = static_cast<model::Annotation*>(baseObject);
349         switch (p)
350         {
351             case PARENT_DIAGRAM:
352                 o->getParentDiagram(v);
353                 return true;
354             case PARENT_BLOCK:
355                 o->getParentBlock(v);
356                 return true;
357             case RELATED_TO:
358                 v = o->getRelatedTo();
359                 return true;
360             default:
361                 break;
362         }
363     }
364     else if (k == BLOCK)
365     {
366         model::Block* o = static_cast<model::Block*>(baseObject);
367         switch (p)
368         {
369             case PARENT_DIAGRAM:
370                 o->getParentDiagram(v);
371                 return true;
372             case PARENT_BLOCK:
373                 o->getParentBlock(v);
374                 return true;
375             case LABEL:
376                 o->getLabel(v);
377                 return true;
378             case PORT_REFERENCE:
379                 o->getPortReference(v);
380                 return true;
381             default:
382                 break;
383         }
384     }
385     else if (k == DIAGRAM)
386     {
387
388     }
389     else if (k == LINK)
390     {
391         model::Link* o = static_cast<model::Link*>(baseObject);
392         switch (p)
393         {
394             case PARENT_DIAGRAM:
395                 o->getParentDiagram(v);
396                 return true;
397             case PARENT_BLOCK:
398                 o->getParentBlock(v);
399                 return true;
400             case LABEL:
401                 o->getLabel(v);
402                 return true;
403             case SOURCE_PORT:
404                 o->getSourcePort(v);
405                 return true;
406             case DESTINATION_PORT:
407                 o->getDestinationPort(v);
408                 return true;
409             default:
410                 break;
411         }
412     }
413     else if (k == PORT)
414     {
415         model::Port* o = static_cast<model::Port*>(baseObject);
416         switch (p)
417         {
418             case SOURCE_BLOCK:
419                 o->getSourceBlock(v);
420                 return true;
421             case CONNECTED_SIGNALS:
422                 v = o->getConnectedSignals().front();
423                 return true;
424             default:
425                 break;
426         }
427     }
428     return false;
429 }
430
431 bool Model::getObjectProperty(model::BaseObject* object, object_properties_t p, std::vector<double>& v) const
432 {
433     model::BaseObject* baseObject = object;
434     if (baseObject == nullptr)
435     {
436         return false;
437     }
438     kind_t k = object->kind();
439
440     if (k == ANNOTATION)
441     {
442         model::Annotation* o = static_cast<model::Annotation*>(baseObject);
443         switch (p)
444         {
445             case GEOMETRY:
446                 o->getGeometry(v);
447                 return true;
448             default:
449                 break;
450         }
451     }
452     else if (k == BLOCK)
453     {
454         model::Block* o = static_cast<model::Block*>(baseObject);
455         switch (p)
456         {
457             case GEOMETRY:
458                 o->getGeometry(v);
459                 return true;
460             case EXPRS:
461                 o->getExprs(v);
462                 return true;
463             case STATE:
464                 o->getState(v);
465                 return true;
466             case DSTATE:
467                 o->getDState(v);
468                 return true;
469             case ODSTATE:
470                 o->getODState(v);
471                 return true;
472             case RPAR:
473                 o->getRpar(v);
474                 return true;
475             case OPAR:
476                 o->getOpar(v);
477                 return true;
478             case EQUATIONS:
479                 o->getEquations(v);
480                 return true;
481             default:
482                 break;
483         }
484     }
485     else if (k == DIAGRAM)
486     {
487         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
488         switch (p)
489         {
490             case PROPERTIES:
491                 o->getProperties(v);
492                 return true;
493             default:
494                 break;
495         }
496     }
497     else if (k == LINK)
498     {
499         model::Link* o = static_cast<model::Link*>(baseObject);
500         switch (p)
501         {
502             case CONTROL_POINTS:
503                 o->getControlPoints(v);
504                 return true;
505             case THICK:
506                 o->getThick(v);
507                 return true;
508             default:
509                 break;
510         }
511     }
512     else if (k == PORT)
513     {
514         switch (p)
515         {
516             default:
517                 break;
518         }
519     }
520     return false;
521 }
522
523 bool Model::getObjectProperty(model::BaseObject* object, object_properties_t p, std::vector<int>& v) const
524 {
525     model::BaseObject* baseObject = object;
526     if (baseObject == nullptr)
527     {
528         return false;
529     }
530     kind_t k = object->kind();
531
532     if (k == ANNOTATION)
533     {
534         switch (p)
535         {
536             default:
537                 break;
538         }
539     }
540     else if (k == BLOCK)
541     {
542         model::Block* o = static_cast<model::Block*>(baseObject);
543         switch (p)
544         {
545             case SIM_DEP_UT:
546                 o->getSimDepUT(v);
547                 return true;
548             case NZCROSS:
549                 o->getNZcross(v);
550                 return true;
551             case NMODE:
552                 o->getNMode(v);
553                 return true;
554             case IPAR:
555                 o->getIpar(v);
556                 return true;
557             case COLOR:
558                 o->getChildrenColor(v);
559                 return true;
560             default:
561                 break;
562         }
563     }
564     else if (k == DIAGRAM)
565     {
566         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
567         switch (p)
568         {
569             case COLOR:
570                 o->getColor(v);
571                 return true;
572             default:
573                 break;
574         }
575     }
576     else if (k == LINK)
577     {
578         switch (p)
579         {
580             default:
581                 break;
582         }
583     }
584     else if (k == PORT)
585     {
586         model::Port* o = static_cast<model::Port*>(baseObject);
587         switch (p)
588         {
589             case DATATYPE:
590                 o->getDataType(v);
591                 return true;
592             default:
593                 break;
594         }
595     }
596     return false;
597 }
598
599 bool Model::getObjectProperty(model::BaseObject* object, object_properties_t p, std::vector<bool>& /*v*/) const
600 {
601     model::BaseObject* baseObject = object;
602     if (baseObject == nullptr)
603     {
604         return false;
605     }
606     kind_t k = object->kind();
607
608     if (k == ANNOTATION)
609     {
610         switch (p)
611         {
612             default:
613                 break;
614         }
615     }
616     else if (k == BLOCK)
617     {
618         switch (p)
619         {
620             default:
621                 break;
622         }
623     }
624     else if (k == DIAGRAM)
625     {
626         switch (p)
627         {
628             default:
629                 break;
630         }
631     }
632     else if (k == LINK)
633     {
634         switch (p)
635         {
636             default:
637                 break;
638         }
639     }
640     else if (k == PORT)
641     {
642         switch (p)
643         {
644             default:
645                 break;
646         }
647     }
648     return false;
649 }
650
651 bool Model::getObjectProperty(model::BaseObject* object, object_properties_t p, std::vector<std::string>& v) const
652 {
653     model::BaseObject* baseObject = object;
654     if (baseObject == nullptr)
655     {
656         return false;
657     }
658     kind_t k = object->kind();
659
660     if (k == ANNOTATION)
661     {
662         switch (p)
663         {
664             default:
665                 break;
666         }
667     }
668     else if (k == BLOCK)
669     {
670         model::Block* o = static_cast<model::Block*>(baseObject);
671         switch (p)
672         {
673             case DIAGRAM_CONTEXT:
674                 o->getContext(v);
675                 return true;
676             default:
677                 break;
678         }
679     }
680     else if (k == DIAGRAM)
681     {
682         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
683         switch (p)
684         {
685             case DIAGRAM_CONTEXT:
686                 o->getContext(v);
687                 return true;
688             default:
689                 break;
690         }
691     }
692     else if (k == LINK)
693     {
694         switch (p)
695         {
696             default:
697                 break;
698         }
699     }
700     else if (k == PORT)
701     {
702         switch (p)
703         {
704             default:
705                 break;
706         }
707     }
708     return false;
709 }
710
711 bool Model::getObjectProperty(model::BaseObject* object, object_properties_t p, std::vector<ScicosID>& v) const
712 {
713     model::BaseObject* baseObject = object;
714     if (baseObject == nullptr)
715     {
716         return false;
717     }
718     kind_t k = object->kind();
719
720     if (k == ANNOTATION)
721     {
722         switch (p)
723         {
724             default:
725                 break;
726         }
727     }
728     else if (k == BLOCK)
729     {
730         model::Block* o = static_cast<model::Block*>(baseObject);
731         switch (p)
732         {
733             case INPUTS:
734                 o->getIn(v);
735                 return true;
736             case OUTPUTS:
737                 o->getOut(v);
738                 return true;
739             case EVENT_INPUTS:
740                 o->getEin(v);
741                 return true;
742             case EVENT_OUTPUTS:
743                 o->getEout(v);
744                 return true;
745             case CHILDREN:
746                 o->getChildren(v);
747                 return true;
748             default:
749                 break;
750         }
751     }
752     else if (k == DIAGRAM)
753     {
754         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
755         switch (p)
756         {
757             case CHILDREN:
758                 o->getChildren(v);
759                 return true;
760             default:
761                 break;
762         }
763     }
764     else if (k == LINK)
765     {
766         switch (p)
767         {
768             default:
769                 break;
770         }
771     }
772     else if (k == PORT)
773     {
774         model::Port* o = static_cast<model::Port*>(baseObject);
775         switch (p)
776         {
777             case CONNECTED_SIGNALS:
778                 v = o->getConnectedSignals();
779                 return true;
780             default:
781                 break;
782         }
783     }
784     return false;
785 }
786
787 } /* namespace org_scilab_modules_scicos */