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