src/Supervision/SuperV.py

   1 #! /usr/bin/env python
   2 #
   3 #  SUPERV Supervision : contains the implementation of interfaces of SuperVision described in SUPERV.idl
   4 #
   5 #  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   6 #  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   7 #
   8 #  This library is free software; you can redistribute it and/or
   9 #  modify it under the terms of the GNU Lesser General Public
  10 #  License as published by the Free Software Foundation; either
  11 #  version 2.1 of the License.
  12 #
  13 #  This library is distributed in the hope that it will be useful,
  14 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 #  Lesser General Public License for more details.
  17 #
  18 #  You should have received a copy of the GNU Lesser General Public
  19 #  License along with this library; if not, write to the Free Software
  20 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21 #
  22 #  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  23 #
  24 #
  25 #  File   : SuperV.py
  26 #  Module : SUPERV
  27
  28 try :
  29     from salome import orb
  30     from salome import lcc
  31     from salome import naming_service
  32     from salome import CORBA
  33     from salome import sg
  34     from salome import SALOMEDS
  35     import SALOME_ModuleCatalog
  36     import SUPERV
  37     import SUPERV_idl
  38 except :
  39     import curses
  40     from LifeCycleCORBA import *
  41     from SALOME_NamingServicePy import *
  42     import SUPERV
  43     import SUPERV_idl
  44     import SALOME_ModuleCatalog
  45 #    try :
  46 #        from libSuperVision_Swig import SuperV_Swig
  47 #        print 'SuperV_Swig imported'
  48 #    except :
  49 #        SuperV_Swig = None
  50     orb = CORBA.ORB_init([''], CORBA.ORB_ID)
  51     lcc = LifeCycleCORBA(orb)
  52     naming_service = SALOME_NamingServicePy_i(orb)
  53
  54 import os
  55 import re
  56 from types import *
  57
  58 #try :
  59 #    SuperVision = SuperV_Swig( len(sys.argv) , sys.argv )
  60 #    SuperVision.Swig = 1
  61 #    print 'SuperV_Swig created'
  62 #except :
  63 #    SuperVision = lcc.FindOrLoadComponent("SuperVisionContainer","SUPERV")
  64 #    SuperVision.Swig = 0
  65 #    print 'Supervision Component loaded'
  66
  67 SuperVision = lcc.FindOrLoadComponent("SuperVisionContainer","SUPERV")
  68 #SuperVision.Swig = 0
  69
  70 modulecatalog = naming_service.Resolve("/Kernel/ModulCatalog")
  71
  72
  73 def createDataflowStudyObject( theStudy , aDataFlow , aBuilder ) :
  74     aStudyObject = theStudy.FindObjectIOR( aDataFlow.G.getIOR() )
  75     if aStudyObject == None :
  76         aComponent = theStudy.FindComponent( "SUPERV" )
  77         if aComponent == None :
  78             print "createDataflowStudyObject Component SUPERV is None"
  79             aComponent = aBuilder.NewComponent( "SUPERV" )
  80             anAttr = aBuilder.FindOrCreateAttribute(aComponent, "AttributeName")
  81             aName = anAttr._narrow( SALOMEDS.AttributeName )
  82             aName.SetValue( modulecatalog.GetComponentInfo( "SUPERV" ).username )
  83             anAttr = aBuilder.FindOrCreateAttribute( aComponent , "AttributePixMap" )
  84             aPixmap = anAttr._narrow( SALOMEDS.AttributePixMap )
  85             aPixmap.SetPixMap( "ICON_OBJBROWSER_Supervision" );
  86             aBuilder.DefineComponentInstance( aComponent , SuperVision )
  87             print "createDataflowStudyObject Component SUPERV is created"
  88         aStudyObject = aBuilder.NewObject( aComponent )
  89         anAttr =  aBuilder.FindOrCreateAttribute( aStudyObject , "AttributeName" )
  90         aName = anAttr._narrow( SALOMEDS.AttributeName )
  91         aName.SetValue( aDataFlow.Name() )
  92         anAttr =  aBuilder.FindOrCreateAttribute( aStudyObject , "AttributeIOR" )
  93         anIORAttr = anAttr._narrow( SALOMEDS.AttributeIOR )
  94         anIORAttr.SetValue( aDataFlow.G.getIOR() )
  95     return aStudyObject
  96
  97 def addDataflowToStudy( theStudy , aDataFlow ) :
  98     aBuilder = theStudy.NewBuilder()
  99     aBuilder.NewCommand()
 100     aStudyObject = createDataflowStudyObject( theStudy , aDataFlow , aBuilder )
 101     if aStudyObject != None :
 102         aBuilder.CommitCommand()
 103         sg.updateObjBrowser( 1 )
 104         print "addDataflowToStudy aStudyObject ",aDataFlow.Name()," added in study"
 105         #theStudy.updateObjBrowser()
 106     else :
 107         print "addDataflowToStudy ERROR aStudyObject is None"
 108         aBuilder.AbortCommand()
 109     return aBuilder,aStudyObject
 110
 111
 112 def PortInputFloat(obj, x):
 113     return obj.Input( SuperVision.AnyValue( CORBA.Any(CORBA.TC_double, x)))
 114
 115 def PortInputLong(obj, x):
 116     return obj.Input( SuperVision.AnyValue( CORBA.Any(CORBA.TC_long, x)))
 117
 118 def PortInputObject(obj, x):
 119     try:
 120         return obj.Input( SuperVision.AnyValue( CORBA.Any(CORBA.TC_Object, x)))
 121     except:
 122         return obj.Input( SuperVision.AnyValue( x ) )
 123
 124 def PortInputString(obj, x):
 125     return obj.Input( SuperVision.AnyValue( CORBA.Any(CORBA.TC_string, x)))
 126
 127 def InputFloat(obj, nodein_port, x):
 128     return obj.Input(nodein_port, SuperVision.AnyValue( CORBA.Any(CORBA.TC_double, x)))
 129
 130 def InputLong(obj, nodein_port, x):
 131     return obj.Input(nodein_port, SuperVision.AnyValue( CORBA.Any(CORBA.TC_long, x)))
 132
 133 def InputObject(obj, nodein_port, x):
 134     try:
 135         return obj.Input(nodein_port, SuperVision.AnyValue( CORBA.Any(CORBA.TC_Object, x)))
 136     except:
 137         return obj.Input(nodein_port, SuperVision.AnyValue( x ) )
 138
 139 def InputString(obj, nodein_port, x):
 140         return obj.Input(nodein_port, SuperVision.AnyValue( CORBA.Any(CORBA.TC_string, x)))
 141
 142
 143
 144 typestring = re.compile(r"_[^_]+_([^_]+)_.*")
 145
 146 def getRealArgs(self,args):
 147     types = []
 148     realargs = []
 149
 150     try:
 151         t = self.this
 152         types.append(typestring.match(self).group(1))
 153         realargs.append(t)
 154     except:
 155         types.append(type(self))
 156         realargs.append(self)
 157     for a in args:
 158         try:
 159             t = a.this
 160             types.append(typestring.match(a).group(1))
 161             realargs.append(t)
 162         except:
 163             types.append(type(a))
 164             realargs.append(a)
 165
 166     return tuple(types), tuple(realargs)
 167
 168 bs_AddInput_valuedict = {
 169      (InstanceType, FloatType) : PortInputFloat,
 170      (InstanceType, IntType) : PortInputLong,
 171      (InstanceType, StringType) : PortInputString,
 172      (InstanceType, InstanceType) : PortInputObject,
 173      (InstanceType, StringType, FloatType) : InputFloat,
 174      (InstanceType, StringType, IntType) : InputLong,
 175      (InstanceType, StringType, StringType) : InputString,
 176      (InstanceType, StringType, InstanceType) : InputObject,
 177      (InstanceType, StringType, ListType) : InputObject,
 178 }
 179
 180
 181 def Args( aService , aNodeName , verbose ):
 182     lenin = len( aService.ServiceinParameter )
 183     infos = aNodeName + 'info = "'
 184     infos = infos + 'NodeName    : ' + aNodeName + '\\n'
 185     infos = infos + 'ServiceName : ' + aService.ServiceName + '\\n'
 186     infos = infos + 'PortNames   : \\n'
 187     defnames = aNodeName + " = " + "'" + aNodeName + "' ; "
 188     i = 0
 189     while i < lenin :
 190         argname = aNodeName + aService.ServiceinParameter[ i ].Parametername
 191         valname = aNodeName + "\\\\"
 192         valname = valname + aService.ServiceinParameter[ i ].Parametername
 193         defnames = defnames + argname + " = " + "'" + valname + "' ; "
 194         infos = infos + str(i) + '. ' + argname + ' : Input'
 195         infos = infos + str(i) + ' '
 196         infos = infos + aService.ServiceinParameter[ i ].Parametername + ' '
 197         infos = infos + aService.ServiceinParameter[ i ].Parametertype + '\\n'
 198         i = i + 1
 199     lenout = len( aService.ServiceoutParameter )
 200     i = 0
 201     while i < lenout :
 202         argname = aNodeName +  aService.ServiceoutParameter[ i ].Parametername
 203         valname = aNodeName + "\\\\"
 204         valname = valname + aService.ServiceoutParameter[ i ].Parametername
 205         defnames = defnames + argname + " = " + "'" + valname + "' ; "
 206         infos = infos + str(lenin+i) + '. ' + argname + ' : Output'
 207         infos = infos + str(i) + ' '
 208         infos = infos + aService.ServiceoutParameter[ i ].Parametername + ' '
 209         infos = infos + aService.ServiceoutParameter[ i ].Parametertype + '\\n'
 210         i = i + 1
 211     infos = infos + '"'
 212     defnames = defnames + infos
 213     if verbose :
 214         defnames = defnames + " ; print " + aNodeName + "info"
 215     return defnames
 216
 217 def Service_Swig( aCatalogService ) :
 218     aService = SuperVision.Service()
 219     aService.ServiceName = aCatalogService.ServiceName
 220     i = 0
 221     while i < len( aCatalogService.ServiceinParameter ) :
 222         p = SuperVision.ServicesParameter( aCatalogService.ServiceinParameter[i].Parametertype , aCatalogService.ServiceinParameter[i].Parametername )
 223         SuperVision.AddInParameter( aService , p )
 224         i = i + 1
 225     i = 0
 226     while i < len( aCatalogService.ServiceoutParameter ) :
 227         p = SuperVision.ServicesParameter( aCatalogService.ServiceoutParameter[i].Parametertype , aCatalogService.ServiceoutParameter[i].Parametername )
 228         SuperVision.AddOutParameter( aService , p )
 229         i = i + 1
 230     return aService
 231
 232 ##########################################################
 233 class CNode:
 234 ##########################################################
 235     def __init__( self , aNode , Verbose ):
 236         self.N = aNode
 237         self.N.Verbose = Verbose
 238     def Name( self ):
 239         return self.N.Name()
 240     def Service( self ):
 241         return self.N.Service()
 242     def Kind( self ):
 243         return self.N.Kind()
 244     def CreationDate( self ):
 245         return self.N.CreationDate()
 246     def LastUpdateDate( self ):
 247         return self.N.LastUpdateDate()
 248     def Version( self ):
 249         return self.N.Version()
 250     def Author( self ):
 251         return self.N.Author()
 252     def Comment( self ):
 253         return self.N.Comment()
 254
 255     def SetName( self , aNewName ):
 256         return self.N.SetName( aNewName )
 257     def SetAuthor( self , anAuthor ):
 258         return self.N.SetAuthor( anAuthor )
 259     def SetComment( self , aComment ):
 260         return self.N.SetComment( aComment )
 261
 262     def Print( self ):
 263         print "Name          ",self.N.Name()
 264         if self.N.IsFactory() :
 265             print "ComponentName ",self.N.GetComponentName()
 266             print "InterfaceName ",self.N.GetInterfaceName()
 267         if self.N.IsStreamGraph() :
 268             Timeout,DataStreamTrace,DeltaTime = self.G.StreamParams()
 269             print "Timeout",Timeout
 270             print "DataStreamTrace",DataStreamTrace
 271             print "DeltaTime",DeltaTime
 272         aService = self.N.Service()
 273         print "Service Name  ",aService.ServiceName
 274         lenin = len( aService.ServiceinParameter )
 275         print "   ",lenin," input argument(s) :"
 276         i = 0
 277         while i < lenin :
 278             print "      ",i,". ",aService.ServiceinParameter[ i ].Parametername," ",aService.ServiceinParameter[ i ].Parametertype
 279             i = i + 1
 280         lenout = len( aService.ServiceoutParameter )
 281         print "   ",lenout," output argument(s) :"
 282         i = 0
 283         while i < lenout :
 284             print "      ",i,". ",aService.ServiceoutParameter[ i ].Parametername," ",aService.ServiceoutParameter[ i ].Parametertype
 285             i = i + 1
 286         aKind = self.N.Kind()
 287         print "KindOfNode",aKind
 288         aFirstCreation = self.N.CreationDate()
 289         print "Creation Date ",aFirstCreation.Day,"-",aFirstCreation.Month,"-",aFirstCreation.Year," ",aFirstCreation.Hour,":",aFirstCreation.Minute,":",aFirstCreation.Second
 290         aLastModification = self.N.LastUpdateDate()
 291         print "Update Date   ",aLastModification.Day,"-",aLastModification.Month,"-",aLastModification.Year," ",aLastModification.Hour,":",aLastModification.Minute,":",aLastModification.Second
 292         print "Version       ",self.N.Version()
 293         print "Author        ",self.N.Author()
 294         if self.N.IsFactory() :
 295             print "Container     ",self.N.GetContainer()
 296         print "Comment       ",self.N.Comment()
 297         print "Coords        ",self.N.X()," ",self.N.Y()
 298     def Port( self , aPortName ):
 299         aPort = self.N.Port( aPortName )
 300         if aPort != None :
 301             myPort = Port( aPort , self.N.Verbose )
 302             return myPort
 303         if self.N.Verbose :
 304             print "Error while creating the Port : ",aPortName
 305         return None
 306     def Input( self , *args ):
 307         types, realargs = getRealArgs(self.N,args)
 308         fn = bs_AddInput_valuedict[types]
 309         anInput = apply( fn, realargs)
 310         if anInput != None :
 311             myInput = Port( anInput , self.N.Verbose )
 312             return myInput
 313         ErrMsg = "Failed to create the Input"
 314         if self.N.Verbose :
 315             print ErrMsg
 316         return anInput
 317     def InStreamPort( self , aParameterName , aParameterType , aDependency ):
 318         aPort = self.N.InStreamPort( aParameterName , aParameterType , aDependency )
 319         if aPort != None :
 320             myPort = StreamPort( aPort , self.N.Verbose )
 321             return myPort
 322         if self.N.Verbose :
 323             print "Error while creating the Port : ",aParameterName
 324         return None
 325     def OutStreamPort( self , aParameterName , aParameterType , aDependency ):
 326         aPort = self.N.OutStreamPort( aParameterName , aParameterType , aDependency )
 327         if aPort != None :
 328             myPort = StreamPort( aPort , self.N.Verbose )
 329             return myPort
 330         if self.N.Verbose :
 331             print "Error while creating the Port : ",aParameterName
 332         return None
 333     def GetInPort( self , aParameterName ):
 334         aPort = self.N.GetInPort( aParameterName )
 335         if aPort != None :
 336             myPort = Port( aPort , self.N.Verbose )
 337             return myPort
 338         if self.N.Verbose :
 339             print "Error while creating the Port : ",aParameterName
 340         return None
 341     def GetOutPort( self , aParameterName ):
 342         aPort = self.N.GetOutPort( aParameterName )
 343         if aPort != None :
 344             myPort = Port( aPort , self.N.Verbose )
 345             return myPort
 346         if self.N.Verbose :
 347             print "Error while creating the Port : ",aParameterName
 348         return None
 349     def GetInStreamPort( self , aParameterName ):
 350         aPort = self.N.GetInStreamPort( aParameterName )
 351         if aPort != None :
 352             myPort = StreamPort( aPort , self.N.Verbose )
 353             return myPort
 354         if self.N.Verbose :
 355             print "Error while creating the Port : ",aParameterName
 356         return None
 357     def GetOutStreamPort( self , aParameterName ):
 358         aPort = self.N.GetOutStreamPort( aParameterName )
 359         if aPort != None :
 360             myPort = StreamPort( aPort , self.N.Verbose )
 361             return myPort
 362         if self.N.Verbose :
 363             print "Error while creating the Port : ",aParameterName
 364         return None
 365     def Ports( self ):
 366         ports = self.N.Ports()
 367         i = 0
 368         while i < len( ports ) :
 369             ports[ i ] = Port( ports[i] , self.N.Verbose )
 370             i = i + 1
 371         return ports
 372     def StreamPorts( self ):
 373         ports = self.N.StreamPorts()
 374         i = 0
 375         while i < len( ports ) :
 376             ports[ i ] = StreamPort( ports[i] , self.N.Verbose )
 377             i = i + 1
 378         return ports
 379     def AllPorts( self ):
 380         allports = self.N.Ports()
 381         lenports = len( allports )
 382         i = 0
 383         while i < lenports :
 384             allports[ i ] = Port( allports[i] , self.N.Verbose )
 385             i = i + 1
 386         ports = self.N.StreamPorts()
 387         i = 0
 388         while i < len( ports ) :
 389             allports.append( StreamPort( ports[i] , self.N.Verbose ) )
 390             i = i + 1
 391         return allports
 392     def ListPorts( self , *args ):
 393         if len( args ) == 0 :
 394             aName = self.N.Name()
 395         else :
 396             aName = args[ 0 ]
 397         ports = self.AllPorts()
 398         listofports = ""
 399         ilst = 0
 400         if len( ports ) :
 401             portsname = ports[ 0 ].Name()
 402             bs = portsname.find('\\')
 403             if bs != -1 :
 404                 portsname1,portsname2 = portsname.split('\\')
 405                 portsname = portsname1 + portsname2
 406             if ports[ 0 ].IsInput():
 407                 listofports = 'I' + aName + portsname
 408             else :
 409                 listofports = 'O' + aName + portsname
 410             i = 1
 411             while i < len( ports ) :
 412                 portsname = ports[ i ].Name()
 413                 bs = portsname.find('\\')
 414                 if bs != -1 :
 415                     portsname1,portsname2 = portsname.split('\\')
 416                     portsname = portsname1 + portsname2
 417                 if ports[ i ].IsInput():
 418                     listofports = listofports + ',' + 'I' + aName + portsname
 419                 else :
 420                     listofports = listofports + ',' + 'O' + aName + portsname
 421                 i = i + 1
 422         print listofports
 423         if len( ports ) == 1 :
 424             listofports = "[" + listofports + "] = " + aName + ".AllPorts()"
 425         else :
 426             listofports = listofports + " = " + aName + ".AllPorts()"
 427         return listofports
 428     def PrintPorts( self ):
 429         ports = self.AllPorts()
 430         i = 0
 431         while i < len( ports ) :
 432             Direction = "Out"
 433             if ports[ i ].IsInput() :
 434                 Direction = "In"
 435             if ( ports[ i ].IsDataStream() ) & ( self.N.IsStreamGraph() == 0 ) :
 436                 if ports[ i ].IsInput() :
 437                     sts,aKindOfSchema,aKindOfInterpolation,aKindOfExtrapolation = ports[ i ].Params()
 438                     print Direction,self.N.Name(),'(',ports[ i ].Name(),ports[ i ].Kind(),ports[ i ].Type(),') = ',ports[ i ].ToString(),ports[ i ].Dependency(),aKindOfSchema,aKindOfInterpolation,aKindOfExtrapolation
 439                 else :
 440                     numberofvalues = ports[ i ].NumberOfValues()
 441                     print Direction,self.N.Name(),'(',ports[ i ].Name(),ports[ i ].Kind(),ports[ i ].Type(),') = ',ports[ i ].ToString(),ports[ i ].Dependency(),'NumberOfValues',numberofvalues
 442             else :
 443                 print Direction,self.N.Name(),'(',ports[ i ].Name(),ports[ i ].Kind(),ports[ i ].Type(),') = ',ports[ i ].ToString()
 444             i = i + 1
 445     def Links( self ) :
 446         links = self.N.Links()
 447         i = 0
 448         while i < len( links ) :
 449             links[ i ] = Link( links[i] , self.N.Verbose )
 450             i = i + 1
 451         return links
 452     def StreamLinks( self ) :
 453         links = self.N.StreamLinks()
 454         i = 0
 455         while i < len( links ) :
 456             links[ i ] = StreamLink( links[i] , self.N.Verbose )
 457             i = i + 1
 458         return links
 459     def AllLinks( self ) :
 460         alllinks = self.N.Links()
 461         lenlinks = len( alllinks )
 462         i = 0
 463         while i < lenlinks :
 464             alllinks[ i ] = Link( alllinks[i] , self.N.Verbose )
 465             i = i + 1
 466         links = self.N.StreamLinks()
 467         i = 0
 468         while i < len( links ) :
 469             alllinks.append( StreamLink( links[i] , self.N.Verbose ) )
 470             i = i + 1
 471         return alllinks
 472     def ListLinks( self , *args ):
 473         links = self.AllLinks()
 474         if len( links ) :
 475             listoflinks = 'L' + links[ 0 ].OutPort().Node().Name()
 476             listoflinks = listoflinks + links[ 0 ].OutPort().Name()
 477             listoflinks = listoflinks + links[ 0 ].InPort().Node().Name()
 478             listoflinks = listoflinks + links[ 0 ].InPort().Name()
 479             i = 1
 480             while i < len( links ) :
 481                 listoflinks = listoflinks + ',' + 'L' + links[ i ].OutPort().Node().Name()
 482                 listoflinks = listoflinks + links[ i ].OutPort().Name()
 483                 listoflinks = listoflinks + links[ i ].InPort().Node().Name()
 484                 listoflinks = listoflinks + links[ i ].InPort().Name()
 485                 i = i + 1
 486         print listoflinks
 487         if len( args ) == 0 :
 488             aName = self.N.Name()
 489         else :
 490             aName = args[ 0 ]
 491         if len( links ) == 1 :
 492             listoflinks = "[" + listoflinks + "] = " + aName + ".AllLinks()"
 493         else :
 494             listoflinks = listoflinks + " = " + aName + ".AllLinks()"
 495         return listoflinks
 496     def PrintLinks( self ):
 497         links = self.AllLinks()
 498         i = 0
 499         while i < len( links ) :
 500             links[i].Print()
 501             i = i + 1
 502     def IsStreamGraph( self ):
 503         return self.N.IsStreamGraph()
 504     def IsGraph( self ):
 505         return self.N.IsGraph()
 506     def IsMacro( self ):
 507         return self.N.IsMacro()
 508     def IsFlowMacro( self ):
 509         return self.N.IsFlowMacro()
 510     def IsStreamMacro( self ):
 511         return self.N.IsStreamMacro()
 512     def IsComputing( self ):
 513         return self.N.IsComputing()
 514     def IsFactory( self ):
 515         return self.N.IsFactory()
 516     def IsInLine( self ):
 517         return self.N.IsInLine()
 518     def IsGOTO( self ):
 519         return self.N.IsGOTO()
 520     def IsLoop( self ):
 521         return self.N.IsLoop()
 522     def IsEndLoop( self ):
 523         return self.N.IsEndLoop()
 524     def IsSwitch( self ):
 525         return self.N.IsSwitch()
 526     def IsEndSwitch( self ):
 527         return self.N.IsEndSwitch()
 528     def GraphLevel( self ) :
 529         return self.N.GraphLevel()
 530     def SubGraph( self ):
 531         return self.N.SubGraph()
 532     def SubStreamGraph( self ):
 533         return self.N.SubStreamGraph()
 534     def Thread( self ):
 535         return self.N.Thread()
 536     def IsWaiting( self ):
 537         return self.N.IsWaiting()
 538     def IsRunning( self ):
 539         return self.N.IsRunning()
 540     def IsDone( self ):
 541         return self.N.IsDone()
 542     def IsSuspended( self ):
 543         return self.N.IsSuspended()
 544     def State( self ):
 545         return self.N.State()
 546     def Control( self ):
 547         return self.N.Control()
 548     def ControlClear( self ):
 549         return self.N.ControlClear()
 550     def ReadyW( self ):
 551         return self.N.ReadyW()
 552     def RunningW( self ):
 553         return self.N.RunningW()
 554     def DoneW( self ):
 555         return self.N.DoneW()
 556     def SuspendedW( self ):
 557         return self.N.SuspendedW()
 558     #def ReRun( self ):
 559     #    return self.N.ReRun()
 560     #def ReStart( self ):
 561     #    return self.N.ReStart()
 562     #def ReRunAt( self , aNodeName ):
 563     #    return self.N.ReRunAt( aNodeName )
 564     #def ReStartAt( self , aNodeName ):
 565     #    return self.N.ReStartAt( aNodeName )
 566     def Ping( self ):
 567         return self.N.ping()
 568     def Kill( self ):
 569         return self.N.Kill()
 570     def KillDone( self ):
 571         return self.N.KillDone()
 572     def Suspend( self ):
 573         return self.N.Suspend()
 574     def SuspendDone( self ):
 575         return self.N.SuspendDone()
 576     def Resume( self ):
 577         return self.N.Resume()
 578     def Stop( self ):
 579         return self.N.Stop()
 580     def Coords( self , X , Y ):
 581         return self.N.Coords( X , Y )
 582     def X( self ):
 583         return self.N.X()
 584     def Y( self ):
 585         return self.N.Y()
 586     def destroy( self ):
 587         self.N.destroy()
 588     def CpuUsed( self ):
 589         return self.N.CpuUsed()
 590
 591 ##########################################################
 592 class FNode(CNode):
 593 ##########################################################
 594     def __init__( self , aNode , Verbose ):
 595         self.N = aNode
 596         self.N.Verbose = Verbose
 597     def GetComponentName( self ):
 598         return self.N.GetComponentName()
 599     def GetInterfaceName( self ):
 600         return self.N._get_interfaceName()
 601     def GetContainer( self ):
 602         return self.N.GetContainer()
 603     def SetComponentName( self , aComponentName ):
 604         return self.N.SetComponentName( aComponentName )
 605     def SetInterfaceName( self , anInterfaceName ):
 606         return self.N.SetInterfaceName( anInterfaceName )
 607     def SetContainer( self , aComputer ):
 608         return self.N.SetContainer( aComputer )
 609     def IsCimpl( self ):
 610         return self.N.isCimpl
 611
 612 ##########################################################
 613 class INode(CNode):
 614 ##########################################################
 615     def __init__( self , aNode , Verbose ):
 616         self.N = aNode
 617         self.N.Verbose = Verbose
 618     def Edit( self , FuncName , PyFunc ) :
 619         import os
 620         import random
 621         suf = str(random.randrange(1,10000))
 622         file = '/tmp/' + FuncName + '_' + suf + '.py'
 623         try :
 624             #d = dir ()
 625             #print "dir()",d
 626             fd = os.open( file , os.O_CREAT | os.O_WRONLY | os.O_TRUNC )
 627             #d = dir (fd)
 628             #print "dir(fd)",d
 629             i = 0
 630             while ( i < len( PyFunc ) ) :
 631                 print i,'/',len( PyFunc ),PyFunc[ i ]
 632                 os.write( fd , PyFunc[ i ] + '\n' )
 633                 i = i + 1
 634             os.close( fd )
 635             edit = '${EDITOR} ' + file
 636             os.system( edit )
 637             fd = os.open( file , os.O_RDONLY )
 638             line = os.read( fd , 132 )
 639             res = ''
 640             while len( line ) :
 641                 res = res + line
 642                 line = os.read( fd , 132 )
 643             os.close( fd )
 644             PyFunc = res.splitlines()
 645             i = 0
 646             while i < len( PyFunc ) :
 647                 print PyFunc[i]
 648                 i = i + 1
 649         except :
 650             print "Open of",file,"failed."
 651         return PyFunc
 652     def SetPyFunction( self , FuncName , aPyFunction ):
 653         return self.N.SetPyFunction( FuncName , aPyFunction )
 654     def PyFunction( self ):
 655         return self.N.PyFunction()
 656     def PyFuncName( self ):
 657         return self.N.PyFuncName()
 658     def InPort( self , aParameterName , aParameterType ):
 659         aPort = self.N.InPort( aParameterName ,
 660                              aParameterType )
 661         if aPort != None :
 662             myPort = Port( aPort , self.N.Verbose )
 663             return myPort
 664         if self.N.Verbose :
 665             print "Error while creating the Port : ",aParameterName
 666         return None
 667     def OutPort( self , aParameterName , aParameterType ):
 668         aPort = self.N.OutPort( aParameterName ,
 669                                 aParameterType )
 670         if aPort != None :
 671             myPort = Port( aPort , self.N.Verbose )
 672             return myPort
 673         if self.N.Verbose :
 674             print "Error while creating the Port : ",aParameterName
 675         return None
 676     def EPyFunc( self ):
 677         PyFunc = self.N.PyFunction()
 678         PyFunc = self.Edit( self.N.PyFuncName() , PyFunc )
 679         self.N.SetPyFunction( self.N.PyFuncName() , PyFunc )
 680
 681 ##########################################################
 682 class GNode(INode):
 683 ##########################################################
 684     def __init__( self , aNode , Verbose ):
 685         self.N = aNode
 686         self.N.Verbose = Verbose
 687     def SetCoupled( self , anInLineNode ):
 688         if self.N.IsGOTO() :
 689             node = self.N.SetCoupled( anInLineNode )
 690         else :
 691             node = None
 692         return node
 693     def Coupled( self ):
 694         node = self.N.Coupled()
 695         if node != None :
 696             if node.IsInLine() :
 697                 node = INode( node , self.N.Verbose )
 698             elif node.IsLoop() :
 699                 node = LNode( node , self.N.Verbose )
 700             elif node.IsEndLoop() :
 701                 node = ELNode( node , self.N.Verbose )
 702             elif node.IsSwitch() :
 703                 node = SNode( node , self.N.Verbose )
 704             elif node.IsEndSwitch() :
 705                 node = ESNode( node , self.N.Verbose )
 706         return node
 707
 708 ##########################################################
 709 class LNode(GNode):
 710 ##########################################################
 711     def __init__( self , aNode , Verbose ):
 712         self.N = aNode
 713         self.N.Verbose = Verbose
 714     def SetPyInit( self , InitName , aPyFunction ):
 715         return self.N.SetPyInit( InitName , aPyFunction )
 716     def PyInit( self ):
 717         return self.N.PyInit()
 718     def PyInitName( self ) :
 719         return self.N.PyInitName()
 720     def EPyInit( self ):
 721         PyFunc = self.N.PyFunction()
 722         PyFunc = self.Edit( self.N.PyFuncName() , PyFunc )
 723         self.N.SetPyFunction( self.N.PyFuncName() , PyFunc )
 724     def SetPyMore( self , MoreName , aPyFunction ):
 725         return self.N.SetPyMore( MoreName , aPyFunction )
 726     def PyMore( self ):
 727         return self.N.PyMore()
 728     def PyMoreName( self ) :
 729         return self.N.PyMoreName()
 730     def EPyMore( self ):
 731         PyMore = self.N.PyMore()
 732         PyMore = self.Edit( self.N.PyMoreName() , PyMore )
 733         self.N.SetPyMore( self.N.PyMoreName() , PyMore )
 734     def SetPyNext( self , NextName , aPyFunction ):
 735         return self.N.SetPyNext( NextName , aPyFunction )
 736     def PyNext( self ):
 737         return self.N.PyNext()
 738     def PyNextName( self ) :
 739         return self.N.PyNextName()
 740     def EPyNext( self ):
 741         PyNext = self.N.PyNext()
 742         PyNext = self.Edit( self.N.PyNextName() , PyNext )
 743         self.N.SetPyNext( self.N.PyNextName() , PyNext )
 744
 745 ##########################################################
 746 class ELNode(GNode):
 747 ##########################################################
 748     def __init__( self , aNode , Verbose ):
 749         self.N = aNode
 750         self.N.Verbose = Verbose
 751
 752 ##########################################################
 753 class SNode(GNode):
 754 ##########################################################
 755     def __init__( self , aNode , Verbose ):
 756         self.N = aNode
 757         self.N.Verbose = Verbose
 758
 759 ##########################################################
 760 class ESNode(GNode):
 761 ##########################################################
 762     def __init__( self , aNode , Verbose ):
 763         self.N = aNode
 764         self.N.Verbose = Verbose
 765
 766 ##########################################################
 767 #class ServicesParameter_Swig :
 768 ##########################################################
 769 #    def __init__( self , aServicesParameter ):
 770 #        self.Parametertype = aServicesParameter.Parametertype
 771 #        self.Parametername = aServicesParameter.Parametername
 772
 773 ##########################################################
 774 class Graph(GNode):
 775 ##########################################################
 776     def __init__( self , aName ):
 777         try:
 778             graph = SuperVision.Graph( aName )
 779         except:
 780             try:
 781                 graph = aName.G.Copy()
 782             except:
 783                 graph = aName
 784         if graph != None :
 785             if graph.IsStreamGraph() :
 786                 aGraph = graph.ToStreamGraph()
 787                 if aGraph != None :
 788                     graph = StreamGraph( aGraph )
 789                 else :
 790                     print "Graph creation failed"
 791             self.G = graph
 792             self.G.Verbose = 1
 793             self.N = graph
 794             self.N.Verbose = 1
 795         else :
 796             print "Graph creation failed"
 797     def CNode( self , *args ):
 798         if len( args ) == 1 :
 799             aService = args[ 0 ]
 800         else :
 801             aComponent = args[ 0 ]
 802             anInterface = args[ 1 ]
 803             aService = args[ 2 ]
 804             NodeComponent = modulecatalog.GetComponent( aComponent )
 805             aService = NodeComponent.GetService( anInterface , aService )
 806         aNode = self.G.CNode( aService )
 807         if aNode != None :
 808             myNode = CNode( aNode , self.G.Verbose )
 809             return myNode
 810         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 811         if self.G.Verbose :
 812             print ErrMsg
 813         return aNode
 814     def Node( self , aComponent , anInterface , aService ):
 815         #if SuperVision.Swig :
 816             #aService = Service_Swig( aService )
 817         return self.FNode( aComponent , anInterface , aService )
 818     def FNodeImpl( self , aComponent , anInterface , aService, isCimpl ):
 819         NodeComponent = modulecatalog.GetComponent( aComponent )
 820         aService = NodeComponent.GetService( anInterface , aService )
 821         aNode = self.G.FNode( aComponent , anInterface , aService, isCimpl )
 822         if aNode != None :
 823             aNode.isCimpl = isCimpl
 824             myNode = FNode( aNode , self.G.Verbose )
 825             return myNode
 826         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 827         if self.G.Verbose :
 828             print ErrMsg
 829         return aNode
 830     def FNode( self , aComponent , anInterface , aService ):
 831         # create node with C++ implementation type by default
 832         NodeComponent = modulecatalog.GetComponent( aComponent )
 833         aService = NodeComponent.GetService( anInterface , aService )
 834         #if SuperVision.Swig :
 835             #aService = Service_Swig( aService )
 836         aNode = self.G.FNode( aComponent , anInterface , aService, SALOME_ModuleCatalog.SO )
 837         if aNode != None :
 838             aNode.isCimpl = 1
 839             myNode = FNode( aNode , self.G.Verbose )
 840             return myNode
 841         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 842         if self.G.Verbose :
 843             print ErrMsg
 844         return aNode
 845     def INode( self , FuncName , aPythonFunction ):
 846         aNode = self.G.INode( FuncName , aPythonFunction )
 847         if aNode != None :
 848             myNode = INode( aNode , self.G.Verbose )
 849             return myNode
 850         ErrMsg = "Failed to create a Node"
 851         if self.G.Verbose :
 852             print ErrMsg
 853             return aNode
 854     def GNode( self , FuncName , aPythonFunction , anINode ):
 855         aNode = self.G.GNode( FuncName , aPythonFunction , anINode )
 856         if aNode != None :
 857             myNode = GNode( aNode , self.G.Verbose )
 858             return myNode
 859         ErrMsg = "Failed to create a Node"
 860         if self.G.Verbose :
 861             print ErrMsg
 862             return aNode
 863     def LNode( self , InitName , InitFunction , MoreName , MoreFunction , NextName , NextFunction ):
 864         aNode,anEndOfLoop = self.G.LNode( InitName , InitFunction , MoreName , MoreFunction , NextName , NextFunction )
 865         if aNode != None :
 866             myNode = LNode( aNode , self.G.Verbose )
 867             myEndOfLoop = INode( anEndOfLoop , self.G.Verbose )
 868             return myNode,myEndOfLoop
 869         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 870         if self.G.Verbose :
 871             print ErrMsg
 872         return aNode
 873     def SNode( self , FuncName , aPythonFunction ):
 874         aNode,anEndOfSwitch = self.G.SNode( FuncName , aPythonFunction )
 875         if aNode != None :
 876             myNode = SNode( aNode , self.G.Verbose )
 877             myEndOfSwitch = INode( anEndOfSwitch , self.G.Verbose )
 878             return myNode,myEndOfSwitch
 879         ErrMsg = "Failed to create a Node"
 880         if self.G.Verbose :
 881             print ErrMsg
 882         return aNode
 883     def MNode( self , aGraphXml ):
 884         aMNode = self.G.MNode( aGraphXml )
 885         if aMNode != None :
 886             myMNode = MNode( aMNode , self.G.Verbose )
 887             return myMNode
 888         ErrMsg = "Failed to create a MNode"
 889         if self.G.Verbose :
 890             print ErrMsg
 891         return aMNode
 892     def GraphMNode( self , aGraph ):
 893         aGraphMNode = self.G.GraphMNode( aGraph.G )
 894         if aGraphMNode != None :
 895             myMNode = MNode( aGraphMNode , self.G.Verbose )
 896             return myMNode
 897         ErrMsg = "Failed to create a MNode"
 898         if self.G.Verbose :
 899             print ErrMsg
 900         return aGraphMNode
 901     def FlowObjRef( self ) :
 902         aGraph = self.G.FlowObjRef()
 903         if aGraph != None :
 904             myGraph = Graph( aGraph )
 905             return myGraph
 906         return aGraph
 907     def StreamObjRef( self ) :
 908         aGraph = self.G.StreamObjRef()
 909         if aGraph != None :
 910             myGraph = StreamGraph( aGraph )
 911             return myGraph
 912         return aGraph
 913     def PrintService( self , aComponent , anInterface , aService ):
 914         NodeComponent = modulecatalog.GetComponent( aComponent )
 915         aService = NodeComponent.GetService( anInterface , aService )
 916         print "ServiceName ",aService.ServiceName," :"
 917         lenin = len( aService.ServiceinParameter )
 918         print "   ",lenin," input argument(s) :"
 919         i = 0
 920         while i < lenin :
 921             print "      ",i,". ",aService.ServiceinParameter[ i ].Parametername," ",aService.ServiceinParameter[ i ].Parametertype
 922             i = i + 1
 923         lenout = len( aService.ServiceoutParameter )
 924         print "   ",lenout," output argument(s) :"
 925         i = 0
 926         while i < lenout :
 927             print "      ",i,". ",aService.ServiceoutParameter[ i ].Parametername," ",aService.ServiceoutParameter[ i ].Parametertype
 928             i = i + 1
 929     def Link( self , aFromNodePort , aToNodePort ):
 930         aLink = self.G.Link( aFromNodePort.P , aToNodePort.P )
 931         if aLink != None :
 932             myLink = Link( aLink , self.G.Verbose )
 933             return myLink
 934         ErrMsg = "Failed to create a Link from " + aFromNodePort.Node().Name() + "(" + aFromNodePort.Name() + ") to " + aToNodePort.Node().Name() + "(" + aToNodePort.Name() + ")"
 935         if self.G.Verbose :
 936             print ErrMsg
 937         return aLink
 938     def Messages( self ):
 939         return self.G.Messages()
 940     def Import( self , anXmlFileName ):
 941         return self.G.Import( anXmlFileName )
 942     def Export( self , anXmlFileName ):
 943         return self.G.Export( anXmlFileName )
 944     def IsReadOnly( self ) :
 945         return self.G.IsReadOnly()
 946     def ComponentRef( self , aFactoryServer , aComponent ) :
 947         return self.G.ComponentRef( aFactoryServer , aComponent )
 948     def IsValid( self ):
 949         return self.G.IsValid()
 950     def IsExecutable( self ):
 951         return self.G.IsExecutable()
 952     def IsEditing( self ):
 953         return self.G.IsEditing()
 954     def IsExecuting( self ):
 955         return self.G.IsExecuting()
 956     def LevelMax( self ):
 957         return self.G.LevelMax()
 958     def ThreadsMax( self ):
 959         return self.G.ThreadsMax()
 960     def SubGraphsNumber( self ):
 961         return self.G.SubGraphsNumber()
 962     def LevelNodes( self , aLevel ):
 963         nodes = self.G.LevelNodes( aLevel )
 964         return self.nodesTuple( nodes )
 965     def Run( self , *args ):
 966         self.S = -1
 967         aService = self.Service()
 968         nargs = len( args )
 969         i = 0
 970         while nargs > 0 :
 971             print aService.ServiceinParameter[ i ].Parametername," = ",args[i]
 972             self.Input( aService.ServiceinParameter[ i ].Parametername , args[i] )
 973             i = i + 1
 974             nargs = nargs - 1
 975         return self.G.Run()
 976     def Start( self , *args ):
 977         self.S = -1
 978         aService = self.Service()
 979         nargs = len( args )
 980         i = 0
 981         while nargs > 0 :
 982             print aService.ServiceinParameter[ i ].Parametername," = ",args[i]
 983             self.Input( aService.ServiceinParameter[ i ].Parametername , args[i] )
 984             i = i + 1
 985             nargs = nargs - 1
 986         return self.G.Start()
 987     def Event( self ):
 988         sts,aNode,anEvent,aState = self.G.Event()
 989         self.S = sts
 990         return sts,aNode,anEvent,aState
 991     def EventNoW( self ):
 992         sts,aNode,anEvent,aState = self.G.EventNoW()
 993         self.S = sts
 994         return sts,aNode,anEvent,aState
 995     def EventW( self ):
 996         sts,aNode,anEvent,aState = self.G.EventW()
 997         self.S = sts
 998         return sts,aNode,anEvent,aState
 999     def NextW( self ):
1000         if self.S != 0 :
1001             sts,aNode,anEvent,aState = self.G.EventW()
1002             self.S = sts
1003             print sts,aNode.Thread(),aNode.SubGraph(),aNode.Name(),anEvent,aState
1004         return sts
1005     def Threads( self ):
1006         return self.G.Threads()
1007     def SuspendedThreads( self ):
1008         return self.G.SuspendedThreads()
1009     def LastLevelDone( self ):
1010         return self.G.LastLevelDone()
1011     def Verbose( self , verbose ):
1012         preverbose = self.G.Verbose
1013         self.G.Verbose = verbose
1014         return preverbose
1015     def Nodes( self ):
1016         nodes = self.G.Nodes()
1017         return self.nodesTuple( nodes )
1018     def nodesTuple( self , nodes ) :
1019         n = len( nodes.CNodes )
1020         i = 0
1021         j = 0
1022         pynodes = []
1023         while i < n :
1024             pynodes.append( CNode( nodes.CNodes[i] , self.G.Verbose ) )
1025             i = i + 1
1026             j = j + 1
1027         n = len( nodes.FNodes )
1028         i = 0
1029         while i < n :
1030             pynodes.append( FNode( nodes.FNodes[i] , self.G.Verbose ) )
1031             i = i + 1
1032             j = j + 1
1033         n = len( nodes.INodes )
1034         i = 0
1035         while i < n :
1036             pynodes.append( INode( nodes.INodes[i] , self.G.Verbose ) )
1037             i = i + 1
1038             j = j + 1
1039         n = len( nodes.GNodes )
1040         i = 0
1041         while i < n :
1042             pynodes.append( GNode( nodes.GNodes[i] , self.G.Verbose ) )
1043             i = i + 1
1044             j = j + 1
1045         n = len( nodes.LNodes )
1046         i = 0
1047         while i < n :
1048             pynodes.append( LNode( nodes.LNodes[i] , self.G.Verbose ) )
1049             i = i + 1
1050             j = j + 1
1051         n = len( nodes.ELNodes )
1052         i = 0
1053         while i < n :
1054             pynodes.append( GNode( nodes.ELNodes[i] , self.G.Verbose ) )
1055             i = i + 1
1056             j = j + 1
1057         n = len( nodes.SNodes )
1058         i = 0
1059         while i < n :
1060             pynodes.append( SNode( nodes.SNodes[i] , self.G.Verbose ) )
1061             i = i + 1
1062             j = j + 1
1063         n = len( nodes.ESNodes )
1064         i = 0
1065         while i < n :
1066             pynodes.append( GNode( nodes.ESNodes[i] , self.G.Verbose ) )
1067             i = i + 1
1068             j = j + 1
1069         n = len( nodes.Graphs )
1070         i = 0
1071         while i < n :
1072             pynodes.append( MNode( nodes.Graphs[i] , self.G.Verbose ) )
1073             i = i + 1
1074             j = j + 1
1075         return pynodes
1076     def ListNodes( self , *args ):
1077         nodes = self.Nodes()
1078         listofnodes = ""
1079         if len( nodes ) :
1080             listofnodes = nodes[ 0 ].Name()
1081             i = 1
1082             while i < len( nodes ) :
1083                 listofnodes = listofnodes + ',' + nodes[ i ].Name()
1084                 i = i + 1
1085         print listofnodes
1086         if len( args ) == 0 :
1087             aName = self.N.Name()
1088         else :
1089             aName = args[ 0 ]
1090         if len( nodes ) == 1 :
1091             listofnodes = "[" + listofnodes + "] = " + aName + ".Nodes()"
1092         else :
1093             listofnodes = listofnodes + " = " + aName + ".Nodes()"
1094         return listofnodes
1095     def PrintNodes( self ):
1096         nodes = self.Nodes()
1097         n = len( nodes )
1098         i = 0
1099         while i < n :
1100             print ' '
1101             nodes[ i ].Print()
1102             i = i + 1
1103     def PrintThreads( self ):
1104         nodes = self.Nodes()
1105         i = 0
1106         while i < len( nodes ) :
1107             print nodes[i].Name(),nodes[i].Thread(),nodes[i].State(),nodes[i].Control(),nodes[i]
1108             i = i + 1
1109     def GLinks( self ):
1110         links = self.G.GLinks()
1111         i = 0
1112         linkslen = len( links )
1113         #print 'GLinks ',linkslen,'Links'
1114         while i < linkslen :
1115             links[ i ] = Link( links[i] , self.G.Verbose )
1116             i = i + 1
1117     def GStreamLinks( self ):
1118         streamlinks = self.G.GStreamLinks()
1119         i = 0
1120         #print 'GStreamLinks ',len( streamlinks ),'StreamLinks'
1121         while i < len( streamlinks ) :
1122             streamlinks[ i ] = StreamLink( streamlinks[i] , self.G.Verbose )
1123             i = i + 1
1124         return streamlinks
1125     def GAllLinks( self ) :
1126         alllinks = self.G.GLinks()
1127         lenlinks = len( alllinks )
1128         i = 0
1129         while i < lenlinks :
1130             alllinks[ i ] = Link( alllinks[i] , self.N.Verbose )
1131             i = i + 1
1132         links = self.G.StreamLinks()
1133         j = 0
1134         while j < len(links) :
1135             alllinks.append( StreamLink( links[j] , self.N.Verbose ) )
1136             i = i + 1
1137             j = j + 1
1138         return alllinks
1139     def ListLinks( self , *args ):
1140         links = self.GAllLinks()
1141         if len( links ) :
1142             listoflinks = 'L' + links[ 0 ].OutPort().Node().Name()
1143             listoflinks = listoflinks + links[ 0 ].OutPort().Name()
1144             listoflinks = listoflinks + links[ 0 ].InPort().Node().Name()
1145             listoflinks = listoflinks + links[ 0 ].InPort().Name()
1146             i = 1
1147             while i < len( links ) :
1148                 listoflinks = listoflinks + ',' + 'L' + links[ i ].OutPort().Node().Name()
1149                 listoflinks = listoflinks + links[ i ].OutPort().Name()
1150                 listoflinks = listoflinks + links[ i ].InPort().Node().Name()
1151                 listoflinks = listoflinks + links[ i ].InPort().Name()
1152                 i = i + 1
1153         print listoflinks
1154         if len( args ) == 0 :
1155             aName = self.N.Name()
1156         else :
1157             aName = args[ 0 ]
1158         if len( links ) == 1 :
1159             listoflinks = "[" + listoflinks + "] = " + aName + ".GAllLinks()"
1160         else :
1161             listoflinks = listoflinks + " = " + aName + ".GAllLinks()"
1162         return listoflinks
1163     def PrintLinks( self ):
1164         links = self.GAllLinks()
1165         i = 0
1166         while i < len( links ) :
1167             links[ i ].Print()
1168             i = i + 1
1169     def SubGraphsNodes( self , ):
1170         graphs = self.G.SubGraphsNodes()
1171         outgraphs = graphs
1172         i = 0
1173         while i < len( graphs ) :
1174             outgraphs[ i ] = Graph( graphs[i].Name() , self.G.Verbose )
1175             outgraphs[ i ].Merge( graphs[i] )
1176             i = i + 1
1177         return outgraphs
1178     def Copy( self ):
1179         aCopy = self.G.Copy()
1180         if aCopy != None:
1181             myCopy = Graph( aCopy )
1182             return myCopy
1183         ErrMsg = "Failed to get a Copy of " + self.G.Name()
1184         if self.G.Verbose :
1185             print ErrMsg
1186         return aCopy
1187     def ToStreamGraph( self ):
1188         aGraph = self.G.ToStreamGraph()
1189         if aGraph != None :
1190             return StreamGraph( aGraph )
1191         return None
1192     def SubGraphsNodes( self , aSubGraphsNumber ):
1193         nodes = self.G.SubGraphsNodes( aSubGraphsNumber )
1194         return self.nodesTuple( nodes )
1195     def Merge( self , aGraph ):
1196         return self.G.Merge( aGraph.G )
1197     def Destroy( self ):
1198         self.N.destroy()
1199
1200 ##########################################################
1201 class GraphE(Graph):
1202 ##########################################################
1203     def __init__( self , aName ):
1204         graph = SuperVision.GraphE( aName )
1205         self.G = graph
1206         self.G.Verbose = 1
1207         self.N = graph
1208         self.N.Verbose = 1
1209     def ToStreamGraph( self ):
1210         aGraph = self.G.ToStreamGraph()
1211         if aGraph != None :
1212             return StreamGraphE( aGraph )
1213         return None
1214
1215 ##########################################################
1216 class MNode(Graph):
1217 ##########################################################
1218     def __init__( self , aMNode , Verbose ):
1219         self.G = aMNode
1220         self.G.Verbose = Verbose
1221         self.N = aMNode
1222         self.N.Verbose = Verbose
1223
1224 ##########################################################
1225 class StreamGraph(Graph):
1226 ##########################################################
1227     def __init__( self , aName ):
1228         try:
1229             graph = SuperVision.StreamGraph( aName )
1230         except:
1231             try:
1232                 graph = aName.G.StreamCopy()
1233             except:
1234                 graph = aName
1235         if graph != None :
1236             self.G = graph
1237             self.G.Verbose = 1
1238             self.N = graph
1239             self.N.Verbose = 1
1240         else :
1241             print "StreamGraph creation failed"
1242     def StreamCopy( self ):
1243         aCopy = self.G.StreamCopy()
1244         if aCopy != None:
1245             myCopy = StreamGraph( aCopy )
1246             return myCopy
1247         ErrMsg = "Failed to get a Copy of " + self.G.Name()
1248         if self.G.Verbose :
1249             print ErrMsg
1250         return aCopy
1251     def StreamLink( self , anOutStreamPort , anInStreamPort ) :
1252         aStreamLink = self.G.StreamLink( anOutStreamPort.P , anInStreamPort.P )
1253         if aStreamLink!= None:
1254             myStreamLink = StreamLink( aStreamLink , self.G.Verbose )
1255             return myStreamLink
1256         ErrMsg = "Failed to make a StreamLink in " + self.G.Name()
1257         if self.G.Verbose :
1258             print ErrMsg
1259         return aStreamLink
1260     def SetStreamParams( self , Timeout , DataStreamTrace , DeltaTime ):
1261         return self.G.SetStreamParams( Timeout , DataStreamTrace , DeltaTime )
1262     def StreamParams( self ):
1263         Timeout,DataStreamTrace,DeltaTime = self.G.StreamParams()
1264         return Timeout,DataStreamTrace,DeltaTime
1265     def ToFlowGraph( self ):
1266         return self.G.ToFlowGraph()
1267     def SubStreamGraphsNumber( self ):
1268         return self.G.SubStreamGraphsNumber()
1269     def SubStreamGraphsNodes( self , aSubStreamGraphsNumber ):
1270         nodes = self.G.SubStreamGraphsNodes( aSubStreamGraphsNumber )
1271         return self.nodesTuple( nodes )
1272     def StreamMerge( self , aStreamGraph ):
1273         return self.G.StreamMerge( aStreamGraph.G )
1274
1275 ##########################################################
1276 class StreamGraphE(StreamGraph):
1277 ##########################################################
1278     def __init__( self , aName ):
1279         graph = SuperVision.StreamGraphE( aName )
1280         self.G = graph
1281         self.G.Verbose = 1
1282         self.N = graph
1283         self.N.Verbose = 1
1284
1285 ##########################################################
1286 class Value:
1287 ##########################################################
1288     def __init__( self , aValue , Verbose ):
1289         self.V = aValue
1290         self.V.Verbose = Verbose
1291     def ToString( self ):
1292         return self.V.ToString()
1293     def ToAny( self ):
1294         return self.V.ToAny()
1295     def Destroy( self ):
1296         self.N.destroy()
1297
1298 ##########################################################
1299 class Port:
1300 ##########################################################
1301     def __init__( self , aPort , Verbose ):
1302         self.P = aPort
1303         self.P.Verbose = Verbose
1304     def Input( self , *args ):
1305         types, realargs = getRealArgs(self.P,args)
1306         fn = bs_AddInput_valuedict[types]
1307         anInput = apply( fn, realargs)
1308         return anInput
1309     def Node( self ):
1310         aNode = self.P.Node()
1311         if aNode != None :
1312             if aNode.IsComputing() :
1313                 myNode = CNode( aNode , self.P.Verbose )
1314             elif aNode.IsFactory() :
1315                 myNode = FNode( aNode , self.P.Verbose )
1316             elif aNode.IsInLine() :
1317                 myNode = INode( aNode , self.P.Verbose )
1318             elif aNode.IsGOTO() :
1319                 myNode = GNode( aNode , self.P.Verbose )
1320             elif aNode.IsLoop() :
1321                 myNode = LNode( aNode , self.P.Verbose )
1322             elif aNode.IsEndLoop() :
1323                 myNode = ELNode( aNode , self.P.Verbose )
1324             elif aNode.IsSwitch() :
1325                 myNode = SNode( aNode , self.P.Verbose )
1326             elif aNode.IsEndSwitch() :
1327                 myNode = ESNode( aNode , self.P.Verbose )
1328             else :
1329                 myNode = None
1330             return myNode
1331         return aNode
1332     def Name( self ):
1333         return self.P.Name()
1334     def Type( self ):
1335         return self.P.Type()
1336     def Link( self ):
1337         aLink = self.P.Link()
1338         if aLink != None :
1339             myLink = Link( aLink , self.P.Verbose )
1340             return myLink
1341         ErrMsg = "Failed to get a Link to " + self.P.Node().Name() + "(" + self.P.Name() + ")"
1342         if self.P.Verbose :
1343             print ErrMsg
1344         return aLink
1345     def Links( self ):
1346         links = self.P.Links()
1347         i = 0
1348         while i < len( links ) :
1349             links[ i ] = Link( links[i] , self.P.Verbose )
1350             i = i + 1
1351         return links
1352     def PrintLinks( self ):
1353         links = self.P.Links()
1354         i = 0
1355         while i < len( links ) :
1356             Link( links[ i ] , self.P.Verbose ).Print()
1357             i = i + 1
1358     def IsInput( self ):
1359         return self.P.IsInput()
1360     def IsLinked( self ):
1361         return self.P.IsLinked()
1362     def HasInput( self ):
1363         return self.P.HasInput()
1364     def Kind( self ) :
1365         return self.P.Kind()
1366     def IsParam( self ):
1367         return self.P.IsParam()
1368     def IsGate( self ):
1369         return self.P.IsGate()
1370     def IsLoop( self ):
1371         return self.P.IsLoop()
1372     def IsInLine( self ):
1373         return self.P.IsInLine()
1374     def IsSwitch( self ):
1375         return self.P.IsSwitch()
1376     def IsEndSwitch( self ):
1377         return self.P.IsEndSwitch()
1378     def IsDataStream( self ):
1379         return self.P.IsDataStream()
1380 #    def IsBus( self ):
1381 #        return self.P.IsBus()
1382     def Done( self ):
1383         return self.P.Done()
1384     def State( self ):
1385         return self.P.State()
1386     def ToString( self ):
1387         return self.P.ToString()
1388     def ToAny( self ):
1389         return self.P.ToAny()
1390     def Print( self ):
1391         if self.P.IsInput() :
1392             if self.P.IsLinked() :
1393                 print "In",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString(),' from ',self.Link().OutPort().Print()
1394             else :
1395                 print "In",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString()
1396         else :
1397             print "Out",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString()
1398     def Destroy( self ):
1399         self.P.destroy()
1400
1401 ##########################################################
1402 class StreamPort(Port):
1403 ##########################################################
1404     def __init__( self , aPort , Verbose ):
1405         self.P = aPort
1406         self.P.Verbose = Verbose
1407     def StreamLink( self ) :
1408         return self.P.StreamLink()
1409     def Dependency( self ) :
1410         return self.P.Dependency()
1411     def SetDependency( self , aDependency ) :
1412         return self.P.SetDependency( aDependency )
1413     def Params( self ) :
1414         sts,aKindOfSchema,aKindOfInterpolation,aKindOfExtrapolation = self.P.Params()
1415         return sts,aKindOfSchema,aKindOfInterpolation,aKindOfExtrapolation
1416     def SetParams( self , aKindOfSchema , aKindOfInterpolation , aKindOfExtrapolation ) :
1417         return self.P.SetParams( aKindOfSchema , aKindOfInterpolation , aKindOfExtrapolation )
1418     def NumberOfValues( self ) :
1419         return self.P.NumberOfValues()
1420     def SetNumberOfValues( self , aNumberOfValues ) :
1421         return self.P.SetNumberOfValues( aNumberOfValues )
1422
1423 ##########################################################
1424 class Link:
1425 ##########################################################
1426     def __init__( self , aLink , Verbose ):
1427         self.L = aLink
1428         self.L.Verbose = Verbose
1429     def OutPort( self ):
1430         aPort = self.L.OutPort()
1431         if aPort != None :
1432             myPort = Port( aPort , self.L.Verbose )
1433             return myPort
1434         if self.L.Verbose :
1435             print "Error while getting the Port : "
1436         return None
1437     def InPort( self ):
1438         aPort = self.L.InPort()
1439         if aPort != None :
1440             myPort = Port( aPort , self.L.Verbose )
1441             return myPort
1442         if self.L.Verbose :
1443             print "Error while getting the Port : "
1444         return None
1445     def Print( self ):
1446         anOutPort = self.L.OutPort()
1447         anOutPortName = anOutPort.Name()
1448         anOutPortKind = anOutPort.Kind()
1449         anOutPortValue = anOutPort.ToString()
1450         anOutNode = anOutPort.Node()
1451         anOutNodeName = anOutNode.Name()
1452         anInPort = self.L.InPort()
1453         anInPortName = anInPort.Name()
1454         anInPortKind = anInPort.Kind()
1455         anInNode = anInPort.Node()
1456         anInNodeName = anInNode.Name()
1457         print anOutNodeName,'(',anOutPortName,' ',anOutPortKind,') =',anOutPortValue,' --> ',anInNodeName,'(',anInPortName,')',' ',anInPortKind
1458     def CoordsSize( self ):
1459         return self.L.CoordsSize()
1460     def AddCoord( self , index , X , Y ):
1461         return self.L.AddCoord( index , X , Y )
1462     def ChangeCoord( self , index , X , Y ):
1463         return self.L.ChangeCoord( index , X , Y )
1464     def RemoveCoord( self , index ):
1465         return self.L.RemoveCoord( index )
1466     def Coords( self , index ):
1467         return self.L.Coords( index )
1468     def destroy( self ):
1469         self.L.destroy()
1470
1471
1472
1473 ##########################################################
1474 class StreamLink(Link):
1475 ##########################################################
1476     def __init__( self , aLink , Verbose ):
1477         self.L = aLink
1478         self.L.Verbose = Verbose
1479     def OutStreamPort( self ):
1480         aPort = self.L.OutStreamPort()
1481         if aPort != None :
1482             myPort = StreamPort( aPort , self.L.Verbose )
1483             return myPort
1484         if self.L.Verbose :
1485             print "Error while getting the Port : "
1486         return None
1487     def InStreamPort( self ):
1488         aPort = self.L.InStreamPort()
1489         if aPort != None :
1490             myPort = StreamPort( aPort , self.L.Verbose )
1491             return myPort
1492         if self.L.Verbose :
1493             print "Error while getting the Port : "
1494         return None