idl/SUPERV.idl

Go to the documentation of this file.

//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
//
//  File   : SUPERV.idl
//  Author : Jean Rahuel
//  $Header:

#ifndef __SUPERV_IDL__
#define __SUPERV_IDL__

#include "SALOME_ModuleCatalog.idl"
#include "SALOME_Component.idl"
#include "SALOMEDS.idl"
module SUPERV {

  enum KindOfPort { UndefinedParameter , 
              ServiceParameter , 
              GateParameter ,
                    InLineParameter , 
              LoopParameter , 
              SwitchParameter ,
                    EndSwitchParameter , 
              GOTOParameter , 
              DataStreamParameter } ;

//  enum KindOfDependency { UndefinedDependency , TimeDependency , IterationDependency } ;

  enum KindOfSchema { SCHENULL , TI , TF , DELTA } ;

  enum KindOfInterpolation { INTERNULL , L0 , L1 } ;

  enum KindOfExtrapolation { EXTRANULL , E0 , E1 } ;

  enum KindOfDataStreamTrace { WithoutTrace , SummaryTrace , DetailedTrace } ;

  enum KindOfNode { FactoryNode , 
              DataFlowGraph , 
              ComputingNode ,
                    InLineNode , 
              LoopNode , 
              EndLoopNode ,
                    SwitchNode , 
              EndSwitchNode , 
              GOTONode , 
              DataStreamGraph ,
                    MacroNode ,
              UnknownNode };

  struct SDate {
    short Second;
    short Minute;
    short Hour;
    short Day;
    short Month;
    short Year;
  };
  enum GraphEvent { UndefinedEvent , 
              NoEvent , 
              NewThreadEvent ,
                    WaitingEvent , 
              ReadyEvent ,
                    RunningEvent , 
              DoneEvent , 
              ErroredEvent ,
                    SuspendEvent , 
              ResumeEvent ,
                    KillEvent , 
              StopEvent } ;

  // UndefinedState : Non existing Node, Port etc...
  enum GraphState { UndefinedState , 
              NoState , 
              EditingState , 
              SuspendState ,
                    WaitingState , 
              ReadyState , 
              SuspendReadyState ,
                    RunningState ,
                    DoneState , 
              ErrorState ,
                    SuspendDoneState , 
              SuspendErroredState ,
                    KillState , 
              StopState ,
              LoadingState, 
              NumberOfGraphStates } ;

  typedef sequence<string> ListOfStrings ;

  interface Value ;

  interface Link ;
  interface StreamLink ;

  typedef sequence<Link> ListOfLinks ;
  typedef sequence<StreamLink> ListOfStreamLinks ;

  interface Port ;
  interface StreamPort ;

  typedef sequence<Port> ListOfPorts ;
  typedef sequence<StreamPort> ListOfStreamPorts ;

  interface CNode ;
  interface FNode ;
  interface INode ;
  interface GNode ;
  interface LNode ;
  interface ELNode ;
  interface SNode ;
  interface ESNode ;
  interface Graph ;
  interface StreamGraph ;

  typedef sequence<CNode>  ListOfCNodes ;
  typedef sequence<FNode>  ListOfFNodes ;
  typedef sequence<INode>  ListOfINodes ;
  typedef sequence<GNode>  ListOfGNodes ;
  typedef sequence<LNode>  ListOfLNodes ;
  typedef sequence<ELNode> ListOfELNodes ;
  typedef sequence<SNode>  ListOfSNodes ;
  typedef sequence<ESNode> ListOfESNodes ;
  typedef sequence<Graph>  ListOfGraphs ;

  struct ListOfNodes {
    ListOfCNodes  CNodes ;
    ListOfFNodes  FNodes ;
    ListOfINodes  INodes ;
    ListOfGNodes  GNodes ;
    ListOfLNodes  LNodes ;
    ListOfELNodes ELNodes ;
    ListOfSNodes  SNodes ;
    ListOfESNodes ESNodes ;
    ListOfGraphs  Graphs ;
  } ;

  // ToSuspendState : will be Suspended before running if waiting or
  //                  will be Suspended while running or
  //                  will be Suspended after run
  // ToSuspendStartState : will be Suspended at the beginning of execution
  // ToSuspendDoneState : will be Suspended after run
  enum ControlState { VoidState , 
                ToSuspendStartState ,
                      ToSuspendState , 
                ToSuspendDoneState ,
                      ToKillState , 
                ToKillDoneState , 
                ToStopState ,
                      NumberOfControlStates } ;




  interface SuperG : Engines::Component, SALOMEDS::Driver {

//DumpPython is defined in SALOME_Component.idl (SALOMEDS::Driver)
//    SALOMEDS::TMPFile DumpPython( in SALOMEDS::Study theStudy ,
//                                  in boolean isPublished ,
//                                  out boolean isValisScript ) ;

    SUPERV::Graph Graph(in string aGraph ) ; // aGraphName or aGraphXmlFile

    SUPERV::Graph GraphE(in string aGraph ) ; // aGraphName or aGraphXmlFile

    SUPERV::StreamGraph StreamGraph(in string aGraph ) ; // aGraphName or aGraphXmlFile

    SUPERV::StreamGraph StreamGraphE(in string aGraph ) ; // aGraphName or aGraphXmlFile

    SUPERV::Value StringValue( in string aString ) ;
    SUPERV::Value AnyValue( in any anAny ) ;
    SUPERV::Graph getGraph(in string ior); // get Graph from is IOR

    SUPERV::StreamGraph getStreamGraph(in string ior); // get Graph from is IOR

  };


  interface CNode : Engines::Component {


    string Name() ;
    SALOME_ModuleCatalog::Service Service() ;
    SUPERV::KindOfNode Kind() ;
    SUPERV::SDate CreationDate() ;
    SUPERV::SDate LastUpdateDate() ;
    string Version() ;
    string Author() ;
    string Comment() ;


    boolean SetName(in string aNewName ) ;
    boolean SetAuthor(in string anAuthor ) ;
    boolean SetComment(in string aComment ) ;

    SUPERV::Port Port( in string aParameterName ) ;

    SUPERV::Port GetInPort( in string aParameterName ) ;

    SUPERV::Port GetOutPort( in string aParameterName ) ;

    SUPERV::StreamPort GetInStreamPort( in string aParameterName ) ;

    SUPERV::StreamPort GetOutStreamPort( in string aParameterName ) ;

    boolean HasStreamPort() ;

    SUPERV::Port Input( in string InputParameterName ,
                        in Value aValue ) ;

    SUPERV::ListOfPorts Ports() ;

    SUPERV::ListOfStreamPorts StreamPorts() ;

    SUPERV::ListOfLinks Links() ;

    SUPERV::ListOfStreamLinks StreamLinks() ;

    boolean IsStreamGraph() ;
    boolean IsGraph() ;

    boolean IsMacro() ;
    boolean IsFlowMacro() ;
    boolean IsStreamMacro() ;

    boolean IsHeadGraph() ;
    long GraphLevel() ;

    boolean IsComputing() ;
    boolean IsFactory() ;
    boolean IsInLine() ;
    boolean IsGOTO() ;
    boolean IsLoop() ;
    boolean IsEndLoop() ;
    boolean IsSwitch() ;
    boolean IsEndSwitch() ;

    long SubGraph() ;
    long SubStreamGraph() ;

    long Thread() ;

    boolean IsWaiting() ;

     boolean IsReady() ;

    boolean IsRunning() ;

    boolean IsDone() ;
    boolean IsSuspended() ;
    SUPERV::GraphState State() ;

    boolean ReadyW() ;

    boolean RunningW() ;

    boolean DoneW() ;

    boolean SuspendedW() ;

    //    boolean Ping();

    boolean Kill();

    boolean KillDone();

    boolean Stop();
    boolean Suspend();
    boolean SuspendDone();

    boolean Resume();


// Control state required : Kill, Suspend, Stop
    SUPERV::ControlState Control() ;
    void ControlClear() ;

    boolean ContainerKill();

    void Coords( in long X , in long Y ) ;
    long X() ;
    long Y() ;
    long CpuUsed() ;

  } ;

  interface FNode : CNode {

    string GetComponentName() ;
    string GetInterfaceName() ;
    string GetContainer() ;
    boolean SetComponentName(in string aComponentName ) ;
    boolean SetInterfaceName(in string anInterfaceName ) ;
    boolean SetContainer(in string aContainer ) ;
    boolean IsCimpl() ;

  } ;
  // InLine Nodes
  interface INode : CNode {

    void SetPyFunction( in string FuncName ,
                        in SUPERV::ListOfStrings aPyInitFunction ) ;
    SUPERV::ListOfStrings PyFunction() ;
    string PyFuncName() ;

    SUPERV::Port InPort( in string aParameterName , in string aParameterType ) ;
    SUPERV::Port OutPort( in string aParameterName , in string aParameterType ) ;

    SUPERV::StreamPort InStreamPort( in string aParameterName , in SALOME_ModuleCatalog::DataStreamType aParameterType , in SALOME_ModuleCatalog::DataStreamDependency aDependency ) ;

    SUPERV::StreamPort OutStreamPort( in string aParameterName , in SALOME_ModuleCatalog::DataStreamType aParameterType , in SALOME_ModuleCatalog::DataStreamDependency aDependency ) ;

  } ;
  // GOTO/EndLoop/EndSwitch Nodes
  interface GNode : INode {

    boolean SetCoupled( in string anInLineNode ) ;
    SUPERV::INode Coupled() ;
  } ;
  // Loop Nodes
  interface LNode : GNode {

    void SetPyInit( in string InitName ,
                            in SUPERV::ListOfStrings aPyInitFunction ) ;
    SUPERV::ListOfStrings PyInit() ;
    string PyInitName() ;

    void SetPyMore( in string MoreName ,
                            in SUPERV::ListOfStrings aPyMoreFunction ) ;
    SUPERV::ListOfStrings PyMore() ;
    string PyMoreName() ;

    void SetPyNext( in string NextName ,
                            in SUPERV::ListOfStrings aPyNextFunction ) ;

    SUPERV::ListOfStrings PyNext() ;
    string PyNextName() ;

  } ;

  // EndOfLoop Nodes
  interface ELNode : GNode {
  } ;

  // Switch Nodes
  interface SNode : GNode {
  } ;

  // EndOfSwitch Nodes
  interface ESNode : GNode {
  } ;


  interface Graph : GNode {

    SUPERV::CNode CNode( in SALOME_ModuleCatalog::Service aService ) ;

    SUPERV::FNode FNode( in string aComponentName ,
                         in string anInterfaceName ,
                         in SALOME_ModuleCatalog::Service aService ,
                in boolean isCimpl ) ;

    SUPERV::INode INode( in string FuncName , in ListOfStrings aPythonFunction ) ;

    SUPERV::GNode GNode( in string FuncName , in ListOfStrings aPythonFunction ,
                         in string anINode ) ;

    SUPERV::LNode LNode( in string InitName , in ListOfStrings InitFunction ,
                         in string MoreName , in ListOfStrings MoreFunction ,
                         in string NextName , in ListOfStrings NextFunction ,
                         out SUPERV::INode anEndOfLoop ) ;

    SUPERV::SNode SNode( in string FuncName , in ListOfStrings aPythonFunction ,
                         out SUPERV::INode anEndOfSwitch ) ;

    SUPERV::Graph MNode( in string aXmlFileName ) ;

    SUPERV::Graph GraphMNode( in Graph aGraph ) ;

    SUPERV::Graph FlowObjRef() ;

    SUPERV::StreamGraph StreamObjRef() ;

    SUPERV::CNode Node( in string aNodeName ) ;

    Engines::Component ComponentRef( in string aComputerContainer ,
                                     in string aComponentName ) ;

    SUPERV::Link Link( in SUPERV::Port OutputPort ,
                       in SUPERV::Port InputPort ) ;

    string Messages() ;

    boolean Import( in string anXmlFile ) ;

    boolean Export( in string anXmlFile ) ;
    
    string SavePY( in boolean importSuperV ) ;
    
    boolean IsReadOnly() ;

    boolean Run() ;

    boolean EventNoW( out SUPERV::CNode aNode , out SUPERV::GraphEvent anEvent ,
                      out SUPERV::GraphState aState ) ;

    boolean Event( out SUPERV::CNode aNode , out SUPERV::GraphEvent anEvent ,
                   out SUPERV::GraphState aState ) ;
    
    // Same as Event but execution of the thread is suspended between the
    // return of EventW and the next call to EventW
    boolean EventW( out SUPERV::CNode aNode , out SUPERV::GraphEvent anEvent ,
                    out SUPERV::GraphState aState ) ;
    
    long EventQSize() ;
    long LevelMax() ;
    SUPERV::ListOfNodes LevelNodes( in long aLevel ) ;
    long ThreadsMax() ;
    
    long Threads();
    long SuspendedThreads();
    boolean IsValid() ;
    boolean IsExecutable() ;
    boolean IsEditing() ;
    boolean IsExecuting() ;
    
    long LastLevelDone() ;
    
    boolean Start() ;
    SUPERV::Graph Copy() ;
    SUPERV::StreamGraph ToStreamGraph() ;
    boolean Merge( in Graph aGraph ) ;
    SUPERV::ListOfNodes Nodes() ;
    SUPERV::ListOfLinks GLinks() ;
    string getIOR();
    
    long SubGraphsNumber() ;
    SUPERV::ListOfNodes SubGraphsNodes( in long SubGraphNumber ) ;

    void Editing();
    
  } ;






  interface StreamGraph : Graph {

    SUPERV::StreamGraph StreamCopy() ;
    SUPERV::StreamGraph StreamMNode( in string aXmlFileName ) ;

    SUPERV::StreamGraph StreamGraphMNode( in StreamGraph aStreamGraph ) ;

    SUPERV::StreamLink StreamLink( in SUPERV::StreamPort OutputPort ,
                                   in SUPERV::StreamPort InputPort ) ;

    SUPERV::ListOfStreamLinks GStreamLinks() ;
    boolean SetStreamParams( in long Timeout ,
                             in SUPERV::KindOfDataStreamTrace DataStreamTrace ,
                             in double DeltaTime ) ;
    void StreamParams( out long Timeout ,
                       out SUPERV::KindOfDataStreamTrace DataStreamTrace ,
                       out double DeltaTime ) ;

    long SubStreamGraphsNumber() ;
    SUPERV::ListOfNodes SubStreamGraphsNodes( in long SubStreamGraphNumber ) ;

    SUPERV::Graph ToFlowGraph() ;

    boolean StreamMerge( in StreamGraph aStreamGraph ) ;

  } ;







  interface Link : Engines::Component {

    SUPERV::Port OutPort() ;

    SUPERV::Port InPort() ;

    // For GUI :
    long CoordsSize() ;
    boolean AddCoord( in long index , in long X , in long Y ) ;
    boolean ChangeCoord( in long index , in long X , in long Y ) ;
    boolean RemoveCoord( in long index ) ;

    boolean Coords( in long index , out long X , out long Y ) ;
    //    void Destroy() ;

    boolean IsValid();

    boolean IsEqual( in SUPERV::Link aLink );

  } ;







  interface StreamLink : Link {

    SUPERV::StreamPort OutStreamPort() ;

    SUPERV::StreamPort InStreamPort() ;


  } ;






  interface Value : Engines::Component {

    string ToString() ;
    any ToAny() ;
    boolean IsIOR() ;
    string ComponentDataType() ;

    //    void Destroy() ;

  } ;

  interface Port : Value {

    boolean Input( in SUPERV::Value aValue ) ;

    SUPERV::CNode Node() ;
    string Name() ;

/* Gets the type of a port.
\return A string defining the type of a port
*/

    string Type() ;

    // Link of an Input Port
    SUPERV::Link Link() ;

    SUPERV::ListOfLinks Links() ;

    boolean IsInput() ;

    boolean HasInput() ;

// Port with link (without Value)
    boolean IsLinked() ;

    // Kind of a Port
    SUPERV::KindOfPort Kind() ;

    // Port from the service of the node
    boolean IsParam() ;
    // Port is a Gate of the node
    boolean IsGate() ;
    // Port is a parameter of an InLineNode
    boolean IsInLine() ;

    // Port is a LoopParameter (InitLoop or DoLoop) of an LoopNode
    boolean IsLoop() ;
    // Port is an output parameter of a SwitchNode connected to an InGate
    // Port is a parameter of a switch node
    boolean IsSwitch() ;
    // Port is an Input parameter of a EndSwitchNode connected to several output ports
    boolean IsEndSwitch() ;

    boolean IsDataStream() ;

    SUPERV::GraphState State() ;
    boolean IsDone() ;

    void Remove() ;

  } ;

  interface StreamPort : Port {

    // Link of a StreamPort
    SUPERV::StreamLink StreamLink() ;

    SALOME_ModuleCatalog::DataStreamDependency Dependency() ;
    boolean SetDependency( in SALOME_ModuleCatalog::DataStreamDependency aDependency ) ;

    boolean SetParams( in KindOfSchema aKindOfSchema ,
                       in KindOfInterpolation aKindOfInterpolation ,
                       in KindOfExtrapolation aKindOfExtrapolation ) ;
    boolean Params( out KindOfSchema aKindOfSchema ,
                    out KindOfInterpolation aKindOfInterpolation ,
                    out KindOfExtrapolation aKindOfExtrapolation ) ;

    boolean SetNumberOfValues( in long aNumberOfValues ) ;
    long NumberOfValues() ;

  } ;

};
#endif

Generated on Tue Sep 19 09:47:57 2006 for SALOME - SUPERV - v.3.2.2 by  1.4.6