idl/SUPERV.idl

   1 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 //  This library is free software; you can redistribute it and/or
   5 //  modify it under the terms of the GNU Lesser General Public
   6 //  License as published by the Free Software Foundation; either
   7 //  version 2.1 of the License.
   8 //
   9 //  This library is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 //  Lesser General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU Lesser General Public
  15 //  License along with this library; if not, write to the Free Software
  16 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  19 //
  20 //
  21 //
  22 //  File   : SUPERV.idl
  23 //  Author : Jean Rahuel
  24 //  $Header:
  25
  26 /*! \file SUPERV.idl This file contains a set of interfaces of the %SUPERVISION module
  27 */
  28
  29 #ifndef __SUPERV_IDL__
  30 #define __SUPERV_IDL__
  31
  32 #include "SALOME_ModuleCatalog.idl"
  33 #include "SALOME_Component.idl"
  34 #include "SALOMEDS.idl"
  35 /*!
  36  The main package of interfaces of %SUPERVISION module
  37 */
  38 module SUPERV {
  39
  40 /*!
  41 This enumeration contains a set of elements defining the type of the port.
  42 \note  <BR>In general, ports represent <STRONG>input or output parameters</STRONG> of the functions,
  43 implemented in different kinds of nodes of the graph.
  44 */
  45   enum KindOfPort { UndefinedParameter , ServiceParameter , GateParameter ,
  46                     InLineParameter , LoopParameter , SwitchParameter ,
  47                     EndSwitchParameter , GOTOParameter } ;
  48
  49 /*!
  50 This enumeration contains a set of elements defining the type of the node.
  51 */
  52   enum KindOfNode { FactoryNode , DataFlowNode , ComputingNode ,
  53                     InLineNode , LoopNode , EndLoopNode ,
  54                     SwitchNode , EndSwitchNode , GOTONode , UnknownNode };
  55
  56 /*!
  57 This struct contains fields defining the date.
  58 */
  59   struct SDate {
  60     short Second;
  61     short Minute;
  62     short Hour;
  63     short Day;
  64     short Month;
  65     short Year;
  66   };
  67 /*!
  68 This enumeration contains a set of elements defining the type of operation, which has been performed
  69 on this node(graph).
  70 */
  71
  72   enum GraphEvent { UndefinedEvent , NoEvent , NewThreadEvent ,
  73                     WaitingEvent , ReadyEvent ,
  74                     RunningEvent , DoneEvent , ErroredEvent ,
  75                     SuspendEvent , ResumeEvent ,
  76                     KillEvent , StopEvent ,
  77                     ReRunEvent , ReStartEvent } ;
  78
  79   // UndefinedState : Non existing Node, Port etc...
  80 /*!
  81 This enumeration contains a set of elements defining the current state of the node(graph).
  82 */
  83
  84   enum GraphState { UndefinedState , NoState , EditingState , SuspendState ,
  85                     WaitingState , ReadyState , SuspendReadyState ,
  86                     RunningState ,
  87                     DoneState , ErrorState ,
  88                     SuspendDoneState , SuspendErroredState ,
  89                     KillState , StopState ,
  90                     ReRunState , ReStartState ,
  91                     NumberOfGraphStates } ;
  92
  93   typedef sequence<string> ListOfStrings ;
  94
  95   interface Value ;
  96
  97   interface Link ;
  98
  99   typedef sequence<Link> ListOfLinks ;
 100
 101   interface Port ;
 102
 103   typedef sequence<Port> ListOfPorts ;
 104
 105   interface CNode ;
 106   interface FNode ;
 107   interface INode ;
 108   interface GNode ;
 109   interface LNode ;
 110   interface ELNode ;
 111   interface SNode ;
 112   interface ESNode ;
 113   typedef sequence<CNode>  ListOfCNodes ;
 114   typedef sequence<FNode>  ListOfFNodes ;
 115   typedef sequence<INode>  ListOfINodes ;
 116   typedef sequence<GNode>  ListOfGNodes ;
 117   typedef sequence<LNode>  ListOfLNodes ;
 118   typedef sequence<ELNode> ListOfELNodes ;
 119   typedef sequence<SNode>  ListOfSNodes ;
 120   typedef sequence<ESNode> ListOfESNodes ;
 121
 122   struct ListOfNodes {
 123     ListOfCNodes  CNodes ;
 124     ListOfFNodes  FNodes ;
 125     ListOfINodes  INodes ;
 126     ListOfGNodes  GNodes ;
 127     ListOfLNodes  LNodes ;
 128     ListOfELNodes ELNodes ;
 129     ListOfSNodes  SNodes ;
 130     ListOfESNodes ESNodes ;
 131   } ;
 132
 133   interface Graph ;
 134
 135   typedef sequence<Graph> ListOfGraphs ;
 136
 137   // ToSuspendState : will be Suspended before running if waiting or
 138   //                  will be Suspended while running or
 139   //                  will be Suspended after run
 140   // ToSuspendStartState : will be Suspended at the beginning of execution
 141   // ToSuspendDoneState : will be Suspended after run
 142 /*!
 143 This enumeration contains a set of elements defining the %ControlState of the node.
 144 The %ControlState gives a possibility to determine the "control actions" which have been done by
 145 the user (Suspend, SuspendDone, Kill, etc...).
 146 */
 147   enum ControlState { VoidState , ToSuspendStartState ,
 148                       ToSuspendState , ToSuspendDoneState ,
 149                       ToKillState , ToKillDoneState , ToStopState ,
 150                       NumberOfControlStates } ;
 151 /*!
 152 The AutomatonState is an internal state of the automaton of the Executor
 153 of the %SuperVision %Engine. It is used for inner debugging purposes only.
 154 */
 155
 156   enum AutomatonState { UnKnownState ,
 157                         DataUndefState ,
 158                         DataWaitingState ,
 159                         DataReadyState ,
 160                         SuspendedReadyState,
 161                         SuspendedReadyToResumeState ,
 162                         ResumedReadyState ,
 163                         KilledReadyState ,
 164                         StoppedReadyState ,
 165                         ExecutingState ,
 166                         SuspendedExecutingState ,
 167                         ResumedExecutingState ,
 168                         KilledExecutingState ,
 169                         StoppedExecutingState ,
 170                         SuccessedExecutingState ,
 171                         ErroredExecutingState ,
 172                         SuspendedSuccessedState ,
 173                         SuspendedErroredState,
 174                         ResumedSuccessedState ,
 175                         ResumedErroredState ,
 176                              KilledSuccessedState ,
 177                         KilledErroredState ,
 178                              StoppedSuccessedState ,
 179                         StoppedErroredState ,
 180                         SuccessedState ,
 181                         ErroredState ,
 182                         SuspendedState ,
 183                         KilledState ,
 184                         StoppedState ,
 185                         SuspendedSuccessedToReStartState ,
 186                         SuspendedErroredToReStartState ,
 187                         ReRunnedState ,
 188                         ReStartedState ,
 189                         NumberOfAutomatonStates
 190                      } ;
 191
 192
 193
 194
 195
 196
 197
 198
 199   ////////////////
 200 /*! \brief interface %SuperG
 201
 202 This interface contains a set of methods necessary for management of a %graph.
 203 */
 204   interface SuperG : Engines::Component, SALOMEDS::Driver {
 205   ////////////////
 206 /*!
 207   Constructs a graph with possibility to read/edit it
 208   \param aGraph  %aGraphName or %aGraphXmlFile
 209 */
 210     SUPERV::Graph Graph(in string aGraph ) ; // aGraphName or aGraphXmlFile
 211
 212 /*!
 213   Constructs a read Only graph ( for execution ).
 214  \note <BR>In this graph there is also a possibility to update nodes, coordinates of the links,
 215   of container names and input data.
 216   \param aGraph  %aGraphName or %aGraphXmlFile
 217 */
 218     SUPERV::Graph GraphE(in string aGraph ) ; // aGraphName or aGraphXmlFile
 219
 220 /*!
 221 Creates a value for %Input method in interface %Node.
 222 */
 223     SUPERV::Value StringValue( in string aString ) ;
 224     SUPERV::Value AnyValue( in any anAny ) ;
 225 /*!
 226  Gets a graph from its %IOR
 227 */
 228     SUPERV::Graph getGraph(in string ior); // get Graph from is IOR
 229
 230   };
 231
 232 /*! \brief Interface of a node
 233
 234 This interface includes a set of methods used for management of the nodes in the graph.
 235 */
 236
 237   //////////////
 238   interface CNode : Engines::Component {
 239   //////////////
 240
 241
 242 /*!
 243 Returns the name of the node(graph).
 244 */
 245     string Name() ;
 246 /*!
 247 Returns the service of this node .
 248 */
 249     SALOME_ModuleCatalog::Service Service() ;
 250 /*!
 251 Returns the type of the node.
 252 */
 253     SUPERV::KindOfNode Kind() ;
 254 /*!
 255 Returns the date of creation of the node(graph).
 256 */
 257     SUPERV::SDate CreationDate() ;
 258 /*!
 259 Returns the date of last update of the node(graph).
 260 */
 261     SUPERV::SDate LastUpdateDate() ;
 262 /*!
 263 Returns the name of the version of the node(graph).
 264 */
 265     string Version() ;
 266 /*!
 267 Returns the name of the author of the node(graph).
 268 */
 269     string Author() ;
 270 /*!
 271 Returns the string containing comments about this node(graph).
 272 */
 273     string Comment() ;
 274
 275
 276 /*!
 277 Sets the name of the node(graph). Returns True if it is updated.
 278 */
 279     boolean SetName(in string aNewName ) ;
 280 /*!
 281 Sets the name of the author. Returns True if it is updated.
 282 */
 283     boolean SetAuthor(in string anAuthor ) ;
 284 /*!
 285 Allows to update the comments about this node(graph).
 286 */
 287     boolean SetComment(in string aComment ) ;
 288
 289 /*!
 290  Gets a port of the node.
 291 */
 292     SUPERV::Port Port( in string aParameterName ) ;
 293
 294 /*!
 295  Enters a value into an Input %Port
 296 */
 297     SUPERV::Port Input( in string InputParameterName ,
 298                         in Value aValue ) ;
 299
 300
 301     // Create an Input %Port and an Output Port in LabelNode or ControlNode
 302     //    boolean BusPort( in string InOutParameterName ,
 303     //                     in string InOutParameterType ,
 304     //                     out SUPERV::Port InputPort ,
 305     //                     out SUPERV::Port OutputPort ) ;
 306     //    boolean BusPorts( in string InputParameterName ,
 307     //                      in string InputParameterType ,
 308     //                      in string OutputParameterName ,
 309     //                      in string OutputParameterType ,
 310     //                      out SUPERV::Port InputPort ,
 311     //                      out SUPERV::Port OutputPort ) ;
 312
 313 /*!
 314   Gets a list of ports of the node(graph)
 315 */
 316     SUPERV::ListOfPorts Ports() ;
 317
 318     // Get list of Links
 319     SUPERV::ListOfLinks Links() ;
 320
 321 /*!
 322 Returns True if this node is a graph.
 323 \note <BR>A node of the graph can also represent in its turn another graph.
 324 */
 325     boolean IsGraph() ;
 326 /*!
 327 Returns True if the node appears to be a %computing node.
 328 */
 329     boolean IsComputing() ;
 330     boolean IsFactory() ;
 331     boolean IsInLine() ;
 332     boolean IsGOTO() ;
 333     boolean IsLoop() ;
 334     boolean IsEndLoop() ;
 335     boolean IsSwitch() ;
 336     boolean IsEndSwitch() ;
 337
 338 /*!
 339  Returns the number of  SubGraphs
 340 */
 341     long SubGraph() ;
 342
 343 /*!
 344 Returns nuber of threads.
 345 */
 346     long Thread() ;
 347
 348 /*!
 349  Returns True if the node(graph) is waiting for Data input
 350 */
 351     boolean IsWaiting() ;
 352
 353 /*!
 354  Returns True if the node(graph) is ready for execution
 355 */
 356      boolean IsReady() ;
 357
 358  /*!
 359  Returns True if the node(graph) is running
 360 */
 361     boolean IsRunning() ;
 362
 363 /*!
 364  Returns True if execution is finished
 365 */
 366
 367     boolean IsDone() ;
 368 /*!
 369  Returns True if execution is suspended
 370 */
 371
 372     boolean IsSuspended() ;
 373 /*!
 374 Returns the current state of the graph.
 375 */
 376     SUPERV::GraphState State() ;
 377
 378     // wait for ready_to_run state, Suspend and return
 379     boolean ReadyW() ;
 380
 381     // wait for running state, Suspend and return
 382     boolean RunningW() ;
 383
 384     // wait for done state, Suspend and return
 385     boolean DoneW() ;
 386
 387     // wait for Suspend state and return
 388     boolean SuspendedW() ;
 389
 390     //    boolean Ping();
 391
 392     // if not running : will be killed when ready to run
 393     // if running : Kill immediatly
 394     boolean Kill();
 395
 396     // will be killed only just after running (only for nodes)
 397     boolean KillDone();
 398
 399     // if not running : will be stopped when ready to run
 400     // if running : Stop immediatly
 401     boolean Stop();
 402
 403     // if not running : will be Suspended when ready to run
 404     // if running : Suspend immediatly
 405     boolean Suspend();
 406
 407     // will be Suspended only just after running
 408     boolean SuspendDone();
 409
 410     // if Suspended : running will continue
 411     // if not Suspended : cancel current ControlState ( Suspend, Kill, ...)
 412     boolean Resume();
 413
 414 /*!
 415  Restarts execution of the node.
 416 */
 417     boolean ReRun();
 418 /*!
 419 Restarts execution of the graph beginning from a definite node.
 420 */
 421     boolean ReRunAt( in string aNodeName );
 422
 423 /*!
 424  Restarts and suspends execution of the node(graph).
 425 */
 426     boolean ReStart();
 427 /*!
 428 Restarts and suspends execution of the graph beginning from a defined node.
 429 */
 430     boolean ReStartAt( in string aNodeName );
 431
 432 /*!
 433  Returns automaton execution state of the node(graph).
 434 */
 435     SUPERV::AutomatonState AutoState() ;
 436
 437     // Control state required : Kill, Suspend, Stop
 438     SUPERV::ControlState Control() ;
 439 /*!
 440 Clears the control state of the node(graph).
 441 */
 442     void ControlClear() ;
 443
 444     boolean ContainerKill();
 445 /*!
 446 Sets the position of the node in the window.
 447 */
 448     void Coords( in long X , in long Y ) ;
 449 /*!
 450 Returns the position of the node along X-axis.
 451 */
 452     long X() ;
 453 /*!
 454 Returns the position of the node along Y-axis.
 455 */
 456     long Y() ;
 457 /*!
 458 Returns the Cpu used by a node in seconds.
 459 */
 460     long CpuUsed() ;
 461
 462   } ;
 463
 464   //////////////
 465   interface FNode : CNode {
 466   //////////////
 467
 468     string GetComponentName() ;
 469     string GetInterfaceName() ;
 470     string GetContainer() ;
 471     boolean SetComponentName(in string aComponentName ) ;
 472     boolean SetInterfaceName(in string anInterfaceName ) ;
 473     boolean SetContainer(in string aContainer ) ;
 474   } ;
 475
 476   // InLine Nodes
 477   //////////////
 478   interface INode : CNode {
 479   //////////////
 480
 481     void SetPyFunction( in string FuncName ,
 482                         in SUPERV::ListOfStrings aPyInitFunction ) ;
 483     SUPERV::ListOfStrings PyFunction() ;
 484     string PyFuncName() ;
 485
 486     // Create Input/Output Port in InLineNodes
 487     SUPERV::Port InPort( in string aParameterName , in string aParameterType ) ;
 488     SUPERV::Port OutPort( in string aParameterName , in string aParameterType ) ;
 489   } ;
 490
 491   // GOTO/EndLoop/EndSwitch Nodes
 492   ///////////////
 493   interface GNode : INode {
 494   ///////////////
 495
 496     boolean SetCoupled( in string anInLineNode ) ;
 497     SUPERV::INode Coupled() ;
 498   } ;
 499
 500   // Loop Nodes
 501   ///////////////
 502   interface LNode : GNode {
 503   ///////////////
 504
 505     void SetPyInit( in string MoreName ,
 506                             in SUPERV::ListOfStrings aPyMoreFunction ) ;
 507     SUPERV::ListOfStrings PyInit() ;
 508     string PyInitName() ;
 509
 510     void SetPyMore( in string MoreName ,
 511                             in SUPERV::ListOfStrings aPyMoreFunction ) ;
 512     SUPERV::ListOfStrings PyMore() ;
 513     string PyMoreName() ;
 514
 515     void SetPyNext( in string NextName ,
 516                             in SUPERV::ListOfStrings aPyNextFunction ) ;
 517     SUPERV::ListOfStrings PyNext() ;
 518     string PyNextName() ;
 519
 520   } ;
 521
 522   // EndOfLoop Nodes
 523   ////////////////
 524   interface ELNode : GNode {
 525   ////////////////
 526   } ;
 527
 528   // Switch Nodes
 529   ///////////////
 530   interface SNode : GNode {
 531   ///////////////
 532   } ;
 533
 534   // EndOfSwitch Nodes
 535   ////////////////
 536   interface ESNode : GNode {
 537   ////////////////
 538   } ;
 539
 540 /*! \brief Interface of a graph
 541
 542 This interface includes a set of methods used for management of the graphs in %SUPERVISION module.
 543 */
 544
 545   ///////////////
 546   interface Graph : INode {
 547   ///////////////
 548
 549     // Create a Computing Node in a Graph
 550     SUPERV::CNode CNode( in SALOME_ModuleCatalog::Service aService ) ;
 551
 552     // Create a Factory Node in a Graph
 553     SUPERV::FNode FNode( in string aComponentName ,
 554                          in string anInterfaceName ,
 555                          in SALOME_ModuleCatalog::Service aService ) ;
 556
 557     // Create an InLine Node in a Graph
 558     SUPERV::INode INode( in string FuncName , in ListOfStrings aPythonFunction ) ;
 559
 560     // Create a GOTO node and link to the corresponding InLine node
 561     SUPERV::GNode GNode( in string FuncName , in ListOfStrings aPythonFunction ,
 562                          in string anINode ) ;
 563
 564     // Create a "for" or "while" node and the corresponding end of loop node
 565     SUPERV::LNode LNode( in string InitName , in ListOfStrings InitFunction ,
 566                          in string MoreName , in ListOfStrings MoreFunction ,
 567                          in string NextName , in ListOfStrings NextFunction ,
 568                          out SUPERV::INode anEndOfLoop ) ;
 569
 570     // Create a "if/elseif/else" or "switch" node and the corresponding end node
 571     SUPERV::SNode SNode( in string FuncName , in ListOfStrings aPythonFunction ,
 572                          out SUPERV::INode anEndOfSwitch ) ;
 573
 574     // Create a CORBA Component Object Reference
 575     Engines::Component ComponentRef( in string aComputerContainer ,
 576                                      in string aComponentName ) ;
 577
 578 /*!
 579  Creates a link  connecting two ports (%Output %Port and %Input %Port) of the nodes in a Graph
 580 */
 581     SUPERV::Link Link( in SUPERV::Port OutputPort ,
 582                        in SUPERV::Port InputPort ) ;
 583
 584 /*!
 585 Imports a graph into a file with XML format
 586 */
 587     boolean Import( in string anXmlFile ) ;
 588 /*!
 589 Exports a graph from a file with XML format
 590 */
 591     boolean Export( in string anXmlFile ) ;
 592 /*!
 593 Returns True if the graph is read Only.
 594 */
 595     boolean IsReadOnly() ;
 596
 597 /*!
 598  Starts asynchronous execution of the graph.
 599 */
 600     boolean Run() ;
 601
 602 /*!
 603  Assigns to the %Node an %Event and a %State of the %Node, if the Event is
 604  available. And returns immediately Nil, NoEvent and NoState if not.
 605  Returns false if the graph is finished, suspended, killed or stopped.
 606 \param aNode  %Node for which this method is called
 607 \param anEvent  An operation, which has been performed on this node(graph).
 608 \param aState   Current state of the graph
 609 */
 610     boolean EventNoW( out SUPERV::CNode aNode , out SUPERV::GraphEvent anEvent ,
 611                       out SUPERV::GraphState aState ) ;
 612
 613 /*!
 614  Assigns to the %Node an %Event and a %State of the %Node, if the Event is
 615  available. Waits if it is not available at the current moment.
 616  Returns false if the graph is finished, suspended, killed or stopped.
 617 \param aNode  %Node for which this method is called
 618 \param anEvent  An operation, which has been performed on this node(graph).
 619 \param aState   Current state of the graph
 620 */
 621     boolean Event( out SUPERV::CNode aNode , out SUPERV::GraphEvent anEvent ,
 622                    out SUPERV::GraphState aState ) ;
 623
 624     // Same as Event but execution of the thread is suspended between the
 625     // return of EventW and the next call to EventW
 626 /*!
 627  Assigns to the %Node an %Event and a %State of the %Node, if the Event is
 628  available. And returns immediately Nil, NoEvent and NoState if not.
 629  Returns false if the graph is finished, suspended, killed or stopped.
 630 \note <BR>Execution of the thread is suspended between the return of this
 631 method and its next usage.
 632 \param aNode  %Node for which this method is called
 633 \param anEvent  An operation, which has been performed on this node(graph).
 634 \param aState   Current state of the graph
 635 */
 636     boolean EventW( out SUPERV::CNode aNode , out SUPERV::GraphEvent anEvent ,
 637                     out SUPERV::GraphState aState ) ;
 638
 639     long LevelMax() ;
 640     SUPERV::ListOfNodes LevelNodes( in long aLevel ) ;
 641     long ThreadsMax() ;
 642 /*!
 643 Returns the number of independent subgraphs
 644 */
 645     long GraphsNumber() ;
 646 /*!
 647 Returns the number of currently running threads.
 648 */
 649     long Threads();
 650 /*!
 651 Returns the number of suspended threads.
 652 */
 653     long SuspendedThreads();
 654 /*!
 655 Returns True if the graph is valid.
 656 */
 657     boolean IsValid() ;
 658 /*!
 659 Returns True if the graph can be executed.
 660 */
 661     boolean IsExecutable() ;
 662 /*!
 663 Returns True if the graph represents a working algorithm.
 664 */
 665     boolean IsDataFlow() ;
 666
 667 /*!
 668 Returns True if the graph is being currently edited.
 669 */
 670     boolean IsEditing() ;
 671 /*!
 672 Returns True if the graph is being currently executed.
 673 */
 674     boolean IsExecuting() ;
 675
 676     long LastLevelDone() ;
 677
 678 /*!
 679  Launches step-by-step execution of the graph.
 680 \note  The execution is suspended immediatly after performance of operations of the first node and
 681 user can specify the nodes, where execution will be again suspended after its resuming.
 682 */
 683     boolean Start() ;
 684 /*!
 685 Allows to copy one graph into another.
 686 */
 687     SUPERV::Graph Copy() ;
 688 /*!
 689 Merges two graphs
 690 */
 691     boolean Merge( in Graph aGraph ) ;
 692 /*!
 693 Returns a list of nodes of the graph.
 694 */
 695     SUPERV::ListOfNodes Nodes() ;
 696 /*!
 697 Returns a list of links of the graph.
 698 */
 699     SUPERV::ListOfLinks GLinks() ;
 700 /*!
 701 Gets IOR of the garph.
 702 */
 703     string getIOR();
 704
 705 /*!
 706 Returns a list of graphs.
 707 \note  Not implemented
 708 */
 709     SUPERV::ListOfGraphs Graphs() ;
 710
 711   } ;
 712
 713
 714
 715
 716
 717 /*! \brief Interface of the %link
 718
 719 This interface contains a set of methods used for representation and management of the links
 720 connecting nodes in a %graph.
 721 */
 722
 723   //////////////
 724   interface Link : Engines::Component {
 725   //////////////
 726 /*!
 727 Associates an %Output %Port to the Link
 728 */
 729     SUPERV::Port OutPort() ;
 730
 731 /*!
 732 Associates an %Input %Port to the Link
 733 */
 734     SUPERV::Port InPort() ;
 735
 736     // For GUI :
 737 /*! \name Methods used for representation of links in GUI of %SALOME application :
 738 */
 739 /*@{*/
 740 /*!
 741 Returns the number of coordinate points which are included in the link.
 742 \note  <BR>Every link can contain a set of coordinate points which constitute it. These points have
 743 index numbers (beginning from 1) and coordinates defining their position in the window. Indexing of
 744 the points starts from input port to output port of the corresponding link.
 745 */
 746     long CoordsSize() ;
 747 /*!
 748 Adds a coordinate point to the link.
 749 \param index  Index of the point.
 750 \param X  Coordinates of the point.
 751 \param Y  Coordinates of the point.
 752 */
 753     boolean AddCoord( in long index , in long X , in long Y ) ;
 754 /*!
 755 Changes the location of a definite coordinate point of the link.
 756 \param index  Index of the point.
 757 \param X  Coordinates of the point.
 758 \param Y  Coordinates of the point.
 759 */
 760
 761     boolean ChangeCoord( in long index , in long X , in long Y ) ;
 762 /*!
 763 Removes a coordinate point of the link.
 764 \param index  Index of the point.
 765 */
 766
 767     boolean RemoveCoord( in long index ) ;
 768
 769 /*!
 770 Sets the location of a coordinate point of the link.
 771 \param index  Index of the point.
 772 \param X  Coordinates of the point.
 773 \param Y  Coordinates of the point.
 774 */
 775
 776     boolean Coords( in long index , out long X , out long Y ) ;
 777 /*@}*/
 778
 779     //    void Destroy() ;
 780
 781   } ;
 782
 783 /*! \brief  %Value interface
 784
 785 This interface contains a set of methods used for setting initial parameters of the ports
 786 */
 787
 788   ///////////////
 789   interface Value : Engines::Component {
 790   ///////////////
 791 /*!
 792 Converts the given value into a value of string type.
 793 */
 794     string ToString() ;
 795 /*!
 796 Converts the given value into a value of independant data type.
 797 */
 798     any ToAny() ;
 799 /*!
 800 Returns True if the value represents an IOR.
 801 */
 802     boolean IsIOR() ;
 803 /*!
 804 Gets data type of the component.
 805 */
 806     string ComponentDataType() ;
 807
 808     //    void Destroy() ;
 809
 810   } ;
 811 /*! \brief  %Port interface
 812
 813 This interface contains a set of methods used for management of the ports.
 814 */
 815
 816   //////////////
 817   interface Port : Value {
 818   //////////////
 819
 820 /*!
 821   Gives a value to an Input %Port
 822 */
 823     boolean Input( in SUPERV::Value aValue ) ;
 824
 825 /*!
 826 Returns the node of the port
 827 */
 828     SUPERV::CNode Node() ;
 829 /*!
 830 Sets the name of the port.
 831 */
 832     string Name() ;
 833
 834     // Type of a Port
 835     string Type() ;
 836
 837     // Link of an Input Port
 838 /*!
 839 Returns the link of an %Input %Port
 840 */
 841     SUPERV::Link Link() ;
 842
 843 /*!
 844 Returns a list of links of an Input %Port of an EndSwitchNode
 845 */
 846     SUPERV::ListOfLinks Links() ;
 847
 848 /*!
 849 Returns True if this port appears to be an %Input %Port of a Node
 850 */
 851     boolean IsInput() ;
 852
 853 /*!
 854 Returns True if an %Input %Value exists for that %Input %Port (without link)
 855 */
 856     boolean HasInput() ;
 857
 858 /*!
 859 Returns True if the %Port is linked (without value)
 860 */
 861 // Port with link (without Value)
 862     boolean IsLinked() ;
 863
 864     // Kind of a Port
 865     SUPERV::KindOfPort Kind() ;
 866
 867     // Port from the service of the node
 868 /*!
 869 Returns True if the %Port is a parameter of a service
 870 */
 871     boolean IsParam() ;
 872     // Port is a Gate of the node
 873 /*!
 874 Returns True if the %Port appears to be a GatePort of the node
 875 */
 876     boolean IsGate() ;
 877     // Port is a parameter of an InLineNode
 878     boolean IsInLine() ;
 879     // Port is a LoopParameter (InitLoop or DoLoop) of an LoopNode
 880     boolean IsLoop() ;
 881     // Port is an output parameter of a SwitchNode connected to an InGate
 882 /*!
 883 Returns True if the %Port appears to be a parameter of a switch node
 884 */
 885     // Port is a parameter of a switch node
 886     boolean IsSwitch() ;
 887     // Port is an Input parameter of a EndSwitchNode connected to several output ports
 888     boolean IsEndSwitch() ;
 889
 890     SUPERV::GraphState State() ;
 891     boolean IsDone() ;
 892
 893   } ;
 894
 895 };
 896 #endif