idl/SUPERV.idl

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