src/Supervision/batchmode_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  CEA/DEN, EDF R&D
   6 #
   7 #
   8 #
   9 #  File   : batchmode_SuperV.py
  10 #  Module : SUPERV
  11
  12 try :
  13     from batchmode_salome import orb
  14     from batchmode_salome import lcc
  15     from batchmode_salome import naming_service
  16     from batchmode_salome import CORBA
  17     from batchmode_salome import myStudy
  18     import SUPERV
  19     import SUPERV_idl
  20 except :
  21     import curses
  22     from LifeCycleCORBA import *
  23     from SALOME_NamingServicePy import *
  24     import SUPERV
  25     import SUPERV_idl
  26     from batchmode_salome import *
  27 #    try :
  28 #        from libSuperVision_Swig import SuperV_Swig
  29 #        print 'SuperV_Swig imported'
  30 #    except :
  31 #        SuperV_Swig = None
  32     orb = CORBA.ORB_init([''], CORBA.ORB_ID)
  33     lcc = LifeCycleCORBA(orb)
  34     naming_service = SALOME_NamingServicePy_i(orb)
  35
  36 import re
  37 from types import *
  38 import SALOMEDS
  39 import SALOMEDS_Attributes_idl
  40 #try :
  41 #    SuperVision = SuperV_Swig( len(sys.argv) , sys.argv )
  42 #    SuperVision.Swig = 1
  43 #    print 'SuperV_Swig created'
  44 #except :
  45 #    SuperVision = lcc.FindOrLoadComponent("SuperVisionContainer","SUPERV")
  46 #    SuperVision.Swig = 0
  47 #    print 'Supervision Component loaded'
  48
  49 SuperVision = lcc.FindOrLoadComponent("SuperVisionContainer","SUPERV")
  50 SuperVision.Swig = 0
  51
  52 modulecatalog = naming_service.Resolve("/Kernel/ModulCatalog")
  53
  54 myBuilder = myStudy.NewBuilder()
  55 father = myStudy.FindComponent("SUPERV")
  56 if father is None:
  57         father = myBuilder.NewComponent("SUPERV")
  58         A1 = myBuilder.FindOrCreateAttribute(father, "AttributeName");
  59         FName = A1._narrow(SALOMEDS.AttributeName)
  60
  61 #        FName.SetValue("Supervision")
  62         Comp = modulecatalog.GetComponent( "SUPERV" )
  63         FName.SetValue( Comp._get_componentusername() )
  64
  65         A2 = myBuilder.FindOrCreateAttribute(father, "AttributePixMap");
  66         aPixmap = A2._narrow(SALOMEDS.AttributePixMap);
  67         aPixmap.SetPixMap( "ICON_OBJBROWSER_Supervision" );
  68         myBuilder.DefineComponentInstance(father,SuperVision)
  69
  70
  71 def PortInputFloat(obj, x):
  72     return obj.Input( SuperVision.AnyValue( CORBA.Any(CORBA.TC_double, x)))
  73
  74 def PortInputLong(obj, x):
  75     return obj.Input( SuperVision.AnyValue( CORBA.Any(CORBA.TC_long, x)))
  76
  77 def PortInputObject(obj, x):
  78     try:
  79         return obj.Input( SuperVision.AnyValue( CORBA.Any(CORBA.TC_Object, x)))
  80     except:
  81         return obj.Input( SuperVision.AnyValue( x ) )
  82
  83 def PortInputString(obj, x):
  84     return obj.Input( SuperVision.AnyValue( CORBA.Any(CORBA.TC_string, x)))
  85
  86 def InputFloat(obj, nodein_port, x):
  87     return obj.Input(nodein_port, SuperVision.AnyValue( CORBA.Any(CORBA.TC_double, x)))
  88
  89 def InputLong(obj, nodein_port, x):
  90     return obj.Input(nodein_port, SuperVision.AnyValue( CORBA.Any(CORBA.TC_long, x)))
  91
  92 def InputObject(obj, nodein_port, x):
  93     try:
  94         return obj.Input(nodein_port, SuperVision.AnyValue( CORBA.Any(CORBA.TC_Object, x)))
  95     except:
  96         return obj.Input(nodein_port, SuperVision.AnyValue( x ) )
  97
  98 def InputString(obj, nodein_port, x):
  99         return obj.Input(nodein_port, SuperVision.AnyValue( CORBA.Any(CORBA.TC_string, x)))
 100
 101
 102 def addStudy(ior):
 103     dataflow = SuperVision.getGraph(ior)
 104     name=dataflow.Name()
 105     itr = myStudy.NewChildIterator(father)
 106     while itr.More():
 107         item=itr.Value()
 108         res,A=item.FindAttribute("AttributeName")
 109         if res:
 110             aName = A._narrow(SALOMEDS.AttributeName)
 111             if aName.Value() == name :
 112                 res, A = myBuilder.FindOrCreateAttribute(item, "AttributeIOR")
 113                 anIOR  = A._narrow(SALOMEDS.AttributeIOR);
 114                 anIOR.SetValue(dataflow.getIOR())
 115                 return
 116         itr.Next()
 117     obj = myBuilder.NewObject(father)
 118     A=myBuilder.FindOrCreateAttribute(obj, "AttributeName")
 119     aName=A._narrow(SALOMEDS.AttributeName)
 120     aName.SetValue(name)
 121     A=myBuilder.FindOrCreateAttribute(obj, "AttributeIOR")
 122     anIOR  = A._narrow(SALOMEDS.AttributeIOR)
 123     anIOR.SetValue(dataflow.getIOR())
 124
 125 typestring = re.compile(r"_[^_]+_([^_]+)_.*")
 126
 127 def getRealArgs(self,args):
 128     types = []
 129     realargs = []
 130
 131     try:
 132         t = self.this
 133         types.append(typestring.match(self).group(1))
 134         realargs.append(t)
 135     except:
 136         types.append(type(self))
 137         realargs.append(self)
 138     for a in args:
 139         try:
 140             t = a.this
 141             types.append(typestring.match(a).group(1))
 142             realargs.append(t)
 143         except:
 144             types.append(type(a))
 145             realargs.append(a)
 146
 147     return tuple(types), tuple(realargs)
 148
 149 bs_AddInput_valuedict = {
 150      (InstanceType, FloatType) : PortInputFloat,
 151      (InstanceType, IntType) : PortInputLong,
 152      (InstanceType, StringType) : PortInputString,
 153      (InstanceType, InstanceType) : PortInputObject,
 154      (InstanceType, StringType, FloatType) : InputFloat,
 155      (InstanceType, StringType, IntType) : InputLong,
 156      (InstanceType, StringType, StringType) : InputString,
 157      (InstanceType, StringType, InstanceType) : InputObject,
 158      (InstanceType, StringType, ListType) : InputObject,
 159 }
 160
 161
 162 def Args( aService , aNodeName , verbose ):
 163     lenin = len( aService.ServiceinParameter )
 164     infos = aNodeName + 'info = "'
 165     infos = infos + 'NodeName    : ' + aNodeName + '\\n'
 166     infos = infos + 'ServiceName : ' + aService.ServiceName + '\\n'
 167     infos = infos + 'PortNames   : \\n'
 168     defnames = aNodeName + " = " + "'" + aNodeName + "' ; "
 169     i = 0
 170     while i < lenin :
 171         argname = aNodeName + aService.ServiceinParameter[ i ].Parametername
 172         valname = aNodeName + "\\\\"
 173         valname = valname + aService.ServiceinParameter[ i ].Parametername
 174         defnames = defnames + argname + " = " + "'" + valname + "' ; "
 175         infos = infos + str(i) + '. ' + argname + ' : Input'
 176         infos = infos + str(i) + ' '
 177         infos = infos + aService.ServiceinParameter[ i ].Parametername + ' '
 178         infos = infos + aService.ServiceinParameter[ i ].Parametertype + '\\n'
 179         i = i + 1
 180     lenout = len( aService.ServiceoutParameter )
 181     i = 0
 182     while i < lenout :
 183         argname = aNodeName +  aService.ServiceoutParameter[ i ].Parametername
 184         valname = aNodeName + "\\\\"
 185         valname = valname + aService.ServiceoutParameter[ i ].Parametername
 186         defnames = defnames + argname + " = " + "'" + valname + "' ; "
 187         infos = infos + str(lenin+i) + '. ' + argname + ' : Output'
 188         infos = infos + str(i) + ' '
 189         infos = infos + aService.ServiceoutParameter[ i ].Parametername + ' '
 190         infos = infos + aService.ServiceoutParameter[ i ].Parametertype + '\\n'
 191         i = i + 1
 192     infos = infos + '"'
 193     defnames = defnames + infos
 194     if verbose :
 195         defnames = defnames + " ; print " + aNodeName + "info"
 196     return defnames
 197
 198 def Service_Swig( aCatalogService ) :
 199     aService = SuperVision.Service()
 200     aService.ServiceName = aCatalogService.ServiceName
 201     i = 0
 202     while i < len( aCatalogService.ServiceinParameter ) :
 203         p = SuperVision.ServicesParameter( aCatalogService.ServiceinParameter[i].Parametertype , aCatalogService.ServiceinParameter[i].Parametername )
 204         SuperVision.AddInParameter( aService , p )
 205         i = i + 1
 206     i = 0
 207     while i < len( aCatalogService.ServiceoutParameter ) :
 208         p = SuperVision.ServicesParameter( aCatalogService.ServiceoutParameter[i].Parametertype , aCatalogService.ServiceoutParameter[i].Parametername )
 209         SuperVision.AddOutParameter( aService , p )
 210         i = i + 1
 211     return aService
 212
 213 ##########################################################
 214 class CNode:
 215 ##########################################################
 216     def __init__( self , aNode , Verbose ):
 217         self.N = aNode
 218         self.N.Verbose = Verbose
 219     def Name( self ):
 220         return self.N.Name()
 221     def Service( self ):
 222         return self.N.Service()
 223     def Kind( self ):
 224         return self.N.Kind()
 225     def CreationDate( self ):
 226         return self.N.CreationDate()
 227     def LastUpdateDate( self ):
 228         return self.N.LastUpdateDate()
 229     def Version( self ):
 230         return self.N.Version()
 231     def Author( self ):
 232         return self.N.Author()
 233     def Comment( self ):
 234         return self.N.Comment()
 235
 236     def SetName( self , aNewName ):
 237         return self.N.SetName( aNewName )
 238     def SetAuthor( self , anAuthor ):
 239         return self.N.SetAuthor( anAuthor )
 240     def SetComment( self , aComment ):
 241         return self.N.SetComment( aComment )
 242
 243     def Print( self ):
 244         print "Name          ",self.N.Name()
 245         if self.N.IsFactory() :
 246             print "ComponentName ",self.N.GetComponentName()
 247             print "InterfaceName ",self.N.GetInterfaceName()
 248         aService = self.N.Service()
 249         print "Service Name  ",aService.ServiceName
 250         lenin = len( aService.ServiceinParameter )
 251         print "   ",lenin," input argument(s) :"
 252         i = 0
 253         while i < lenin :
 254             print "      ",i,". ",aService.ServiceinParameter[ i ].Parametername," ",aService.ServiceinParameter[ i ].Parametertype
 255             i = i + 1
 256         lenout = len( aService.ServiceoutParameter )
 257         print "   ",lenout," output argument(s) :"
 258         i = 0
 259         while i < lenout :
 260             print "      ",i,". ",aService.ServiceoutParameter[ i ].Parametername," ",aService.ServiceoutParameter[ i ].Parametertype
 261             i = i + 1
 262         aKind = self.N.Kind()
 263         print "KindOfNode",aKind
 264         aFirstCreation = self.N.CreationDate()
 265         print "Creation Date ",aFirstCreation.Day,"-",aFirstCreation.Month,"-",aFirstCreation.Year," ",aFirstCreation.Hour,":",aFirstCreation.Minute,":",aFirstCreation.Second
 266         aLastModification = self.N.LastUpdateDate()
 267         print "Update Date   ",aLastModification.Day,"-",aLastModification.Month,"-",aLastModification.Year," ",aLastModification.Hour,":",aLastModification.Minute,":",aLastModification.Second
 268         print "Version       ",self.N.Version()
 269         print "Author        ",self.N.Author()
 270         if self.N.IsFactory() :
 271             print "Container     ",self.N.GetContainer()
 272         print "Comment       ",self.N.Comment()
 273         print "Coords        ",self.N.X()," ",self.N.Y()
 274     def Port( self , aPortName ):
 275         aPort = self.N.Port( aPortName )
 276         if aPort != None :
 277             myPort = Port( aPort , self.N.Verbose )
 278             return myPort
 279         if self.N.Verbose :
 280             print "Error while creating the Port : ",aPortName
 281         return None
 282     def Input( self , *args ):
 283         types, realargs = getRealArgs(self.N,args)
 284         fn = bs_AddInput_valuedict[types]
 285         anInput = apply( fn, realargs)
 286         if anInput != None :
 287             myInput = Port( anInput , self.N.Verbose )
 288             return myInput
 289         ErrMsg = "Failed to create the Input"
 290         if self.N.Verbose :
 291             print ErrMsg
 292         return anInput
 293 #    def BusPort( self , InOutParameterName , InOutParameterType ):
 294 #        sts,inp,outp = self.N.BusPort( InOutParameterName ,
 295 #                                       InOutParameterType )
 296 #        inp = Port( inp , self.N.Verbose )
 297 #        outp = Port( outp , self.N.Verbose )
 298 #        return sts,inp,outp
 299 #    def BusPorts( self , InputParameterName , InputParameterType ,
 300 #                  OutputParameterName , OutputParameterType ):
 301 #        sts,inp,outp = self.N.BusPorts( InputParameterName ,
 302 #                                        InputParameterType ,
 303 #                                        OutputParameterName ,
 304 #                                        OutputParameterType )
 305 #        inp = Port( inp , self.N.Verbose )
 306 #        outp = Port( outp , self.N.Verbose )
 307 #        return sts,inp,outp
 308     def Ports( self ):
 309         ports = self.N.Ports()
 310         i = 0
 311         while i < len( ports ) :
 312             ports[ i ] = Port( ports[i] , self.N.Verbose )
 313             i = i + 1
 314         return ports
 315     def ListPorts( self , *args ):
 316         if len( args ) == 0 :
 317             aName = self.N.Name()
 318         else :
 319             aName = args[ 0 ]
 320         ports = self.N.Ports()
 321         listofports = ""
 322         if len( ports ) :
 323             portsname = ports[ 0 ].Name()
 324             bs = portsname.find('\\')
 325             if bs != -1 :
 326                 portsname1,portsname2 = portsname.split('\\')
 327                 portsname = portsname1 + portsname2
 328             listofports = aName + portsname
 329             i = 1
 330             while i < len( ports ) :
 331                 portsname = ports[ i ].Name()
 332                 bs = portsname.find('\\')
 333                 if bs != -1 :
 334                     portsname1,portsname2 = portsname.split('\\')
 335                     portsname = portsname1 + portsname2
 336                 listofports = listofports + ',' + aName + portsname
 337                 i = i + 1
 338         print listofports
 339         if len( ports ) == 1 :
 340             listofports = "[" + listofports + "] = " + aName + ".Ports()"
 341         else :
 342             listofports = listofports + " = " + aName + ".Ports()"
 343         return listofports
 344     def PrintPorts( self ):
 345         ports = self.N.Ports()
 346         i = 0
 347         while i < len( ports ) :
 348             Direction = "Out"
 349             if ports[ i ].IsInput() :
 350                 Direction = "In"
 351             print Direction,self.N.Name(),'(',ports[ i ].Name(),ports[ i ].Kind(),ports[ i ].Type(),') = ',ports[ i ].ToString()
 352             i = i + 1
 353     def Links( self ) :
 354         links = self.N.Links()
 355         i = 0
 356         while i < len( links ) :
 357             links[ i ] = Link( links[i] , self.N.Verbose )
 358             i = i + 1
 359         return links
 360     def PrintLinks( self ):
 361         links = self.Links()
 362         i = 0
 363         while i < len( links ) :
 364             links[i].Print()
 365             i = i + 1
 366     def IsGraph( self ):
 367         return self.N.IsGraph()
 368     def IsComputing( self ):
 369         return self.N.IsComputing()
 370     def IsFactory( self ):
 371         return self.N.IsFactory()
 372     def IsInLine( self ):
 373         return self.N.IsInLine()
 374     def IsGOTO( self ):
 375         return self.N.IsGOTO()
 376     def IsLoop( self ):
 377         return self.N.IsLoop()
 378     def IsEndLoop( self ):
 379         return self.N.IsEndLoop()
 380     def IsSwitch( self ):
 381         return self.N.IsSwitch()
 382     def IsEndSwitch( self ):
 383         return self.N.IsEndSwitch()
 384     def SubGraph( self ):
 385         return self.N.SubGraph()
 386     def Thread( self ):
 387         return self.N.Thread()
 388     def IsWaiting( self ):
 389         return self.N.IsWaiting()
 390     def IsRunning( self ):
 391         return self.N.IsRunning()
 392     def IsDone( self ):
 393         return self.N.IsDone()
 394     def IsSuspended( self ):
 395         return self.N.IsSuspended()
 396     def State( self ):
 397         return self.N.State()
 398     def Control( self ):
 399         return self.N.Control()
 400     def ControlClear( self ):
 401         return self.N.ControlClear()
 402     def AutoState( self ):
 403         return self.N.AutoState()
 404     def ReadyW( self ):
 405         return self.N.ReadyW()
 406     def RunningW( self ):
 407         return self.N.RunningW()
 408     def DoneW( self ):
 409         return self.N.DoneW()
 410     def SuspendedW( self ):
 411         return self.N.SuspendedW()
 412     def ReRun( self ):
 413         return self.N.ReRun()
 414     def ReStart( self ):
 415         return self.N.ReStart()
 416     def ReRunAt( self , aNodeName ):
 417         return self.N.ReRunAt( aNodeName )
 418     def ReStartAt( self , aNodeName ):
 419         return self.N.ReStartAt( aNodeName )
 420     def Ping( self ):
 421         return self.N.ping()
 422     def Kill( self ):
 423         return self.N.Kill()
 424     def KillDone( self ):
 425         return self.N.KillDone()
 426     def Suspend( self ):
 427         return self.N.Suspend()
 428     def SuspendDone( self ):
 429         return self.N.SuspendDone()
 430     def Resume( self ):
 431         return self.N.Resume()
 432     def Stop( self ):
 433         return self.N.Stop()
 434     def Coords( self , X , Y ):
 435         return self.N.Coords( X , Y )
 436     def X( self ):
 437         return self.N.X()
 438     def Y( self ):
 439         return self.N.Y()
 440     def destroy( self ):
 441         self.N.destroy()
 442
 443 ##########################################################
 444 class FNode(CNode):
 445 ##########################################################
 446     def __init__( self , aNode , Verbose ):
 447         self.N = aNode
 448         self.N.Verbose = Verbose
 449     def GetComponentName( self ):
 450         return self.N.ComponentName()
 451     def GetInterfaceName( self ):
 452         return self.N._get_interfaceName()
 453     def GetContainer( self ):
 454         return self.N.Container()
 455     def SetComponentName( self , aComponentName ):
 456         return self.N.SetComponentName( aComponentName )
 457     def SetInterfaceName( self , anInterfaceName ):
 458         return self.N.SetInterfaceName( anInterfaceName )
 459     def SetContainer( self , aComputer ):
 460         return self.N.SetContainer( aComputer )
 461
 462 ##########################################################
 463 class INode(CNode):
 464 ##########################################################
 465     def __init__( self , aNode , Verbose ):
 466         self.N = aNode
 467         self.N.Verbose = Verbose
 468     def Edit( self , FuncName , PyFunc ) :
 469         file = '/tmp/' + FuncName + '.py'
 470         i = 0
 471         fd = os.open( file , os.O_CREAT | os.O_WRONLY | os.O_TRUNC )
 472         while ( i < len( PyFunc ) ) :
 473             os.write( fd , PyFunc[ i ] + '\n' )
 474             i = i + 1
 475         edit = '${EDITOR} ' + file
 476         os.system( edit )
 477         fd = os.open( file , os.O_RDONLY )
 478         line = os.read( fd , 132 )
 479         res = ''
 480         while len( line ) :
 481             res = res + line
 482             line = os.read( fd , 132 )
 483         PyFunc = res.splitlines()
 484         i = 0
 485         while i < len( PyFunc ) :
 486             print PyFunc[i]
 487             i = i + 1
 488         return PyFunc
 489     def SetPyFunction( self , FuncName , aPyFunction ):
 490         return self.N.SetPyFunction( FuncName , aPyFunction )
 491     def PyFunction( self ):
 492         return self.N.PyFunction()
 493     def PyFuncName( self ):
 494         return self.N.PyFuncName()
 495     def EPyFunc( self ):
 496         PyFunc = self.N.PyFunction()
 497         PyFunc = self.Edit( self.N.PyFuncName() , PyFunc )
 498         self.N.SetPyFunction( self.N.PyFuncName() , PyFunc )
 499     def InPort( self , aParameterName , aParameterType ):
 500         aPort = self.N.InPort( aParameterName ,
 501                              aParameterType )
 502         if aPort != None :
 503             myPort = Port( aPort , self.N.Verbose )
 504             return myPort
 505         if self.N.Verbose :
 506             print "Error while creating the Port : ",aParameterName
 507         return None
 508     def OutPort( self , aParameterName , aParameterType ):
 509         aPort = self.N.OutPort( aParameterName ,
 510                                 aParameterType )
 511         if aPort != None :
 512             myPort = Port( aPort , self.N.Verbose )
 513             return myPort
 514         if self.N.Verbose :
 515             print "Error while creating the Port : ",aParameterName
 516         return None
 517
 518 ##########################################################
 519 class GNode(INode):
 520 ##########################################################
 521     def __init__( self , aNode , Verbose ):
 522         self.N = aNode
 523         self.N.Verbose = Verbose
 524     def SetCoupled( self , anInLineNode ):
 525         if self.N.IsGOTO() :
 526             node = self.N.SetCoupled( anInLineNode )
 527         else :
 528             node = None
 529         return node
 530     def Coupled( self ):
 531         node = self.N.Coupled()
 532         if node != None :
 533             if node.IsInLine() :
 534                 node = INode( node , self.N.Verbose )
 535             elif node.IsLoop() :
 536                 node = LNode( node , self.N.Verbose )
 537             elif node.IsEndLoop() :
 538                 node = ELNode( node , self.N.Verbose )
 539             elif node.IsSwitch() :
 540                 node = SNode( node , self.N.Verbose )
 541             elif node.IsEndSwitch() :
 542                 node = ESNode( node , self.N.Verbose )
 543         return node
 544
 545 ##########################################################
 546 class LNode(GNode):
 547 ##########################################################
 548     def __init__( self , aNode , Verbose ):
 549         self.N = aNode
 550         self.N.Verbose = Verbose
 551     def SetPyInit( self , InitName , aPyFunction ):
 552         return self.N.SetPyInit( InitName , aPyFunction )
 553     def PyInit( self ):
 554         return self.N.PyInit()
 555     def PyInitName( self ) :
 556         return self.N.PyInitName()
 557     def EPyInit( self ):
 558         PyFunc = self.N.PyFunction()
 559         PyFunc = self.Edit( self.N.PyFuncName() , PyFunc )
 560         self.N.SetPyFunction( self.N.PyFuncName() , PyFunc )
 561     def SetPyMore( self , MoreName , aPyFunction ):
 562         return self.N.SetPyMore( MoreName , aPyFunction )
 563     def PyMore( self ):
 564         return self.N.PyMore()
 565     def PyMoreName( self ) :
 566         return self.N.PyMoreName()
 567     def EPyMore( self ):
 568         PyMore = self.N.PyMore()
 569         PyMore = self.Edit( self.N.PyMoreName() , PyMore )
 570         self.N.SetPyMore( self.N.PyMoreName() , PyMore )
 571     def SetPyNext( self , NextName , aPyFunction ):
 572         return self.N.SetPyNext( NextName , aPyFunction )
 573     def PyNext( self ):
 574         return self.N.PyNext()
 575     def PyNextName( self ) :
 576         return self.N.PyNextName()
 577     def EPyNext( self ):
 578         PyNext = self.N.PyNext()
 579         PyNext = self.Edit( self.N.PyNextName() , PyNext )
 580         self.N.SetPyNext( self.N.PyNextName() , PyNext )
 581
 582 ##########################################################
 583 class ELNode(GNode):
 584 ##########################################################
 585     def __init__( self , aNode , Verbose ):
 586         self.N = aNode
 587         self.N.Verbose = Verbose
 588
 589 ##########################################################
 590 class SNode(GNode):
 591 ##########################################################
 592     def __init__( self , aNode , Verbose ):
 593         self.N = aNode
 594         self.N.Verbose = Verbose
 595
 596 ##########################################################
 597 class ESNode(GNode):
 598 ##########################################################
 599     def __init__( self , aNode , Verbose ):
 600         self.N = aNode
 601         self.N.Verbose = Verbose
 602
 603 ##########################################################
 604 #class ServicesParameter_Swig :
 605 ##########################################################
 606 #    def __init__( self , aServicesParameter ):
 607 #        self.Parametertype = aServicesParameter.Parametertype
 608 #        self.Parametername = aServicesParameter.Parametername
 609
 610 ##########################################################
 611 class Graph(INode):
 612 ##########################################################
 613     def __init__( self , aName ):
 614         try:
 615             graph = SuperVision.Graph( aName )
 616         except:
 617             try:
 618                 graph = aName.G.Copy()
 619             except:
 620                 graph = None
 621         if graph != None :
 622             self.G = graph
 623             self.G.Verbose = 1
 624             self.N = graph
 625             self.N.Verbose = 1
 626         else :
 627             print "Graph creation failed"
 628     def CNode( self , *args ):
 629         if len( args ) == 1 :
 630             aService = args[ 0 ]
 631         else :
 632             aComponent = args[ 0 ]
 633             anInterface = args[ 1 ]
 634             aService = args[ 2 ]
 635             NodeComponent = modulecatalog.GetComponent( aComponent )
 636             aService = NodeComponent.GetService( anInterface , aService )
 637         aNode = self.G.CNode( aService )
 638         if aNode != None :
 639             myNode = CNode( aNode , self.G.Verbose )
 640             return myNode
 641         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 642         if self.G.Verbose :
 643             print ErrMsg
 644         return aNode
 645     def Node( self , aComponent , anInterface , aService ):
 646         if SuperVision.Swig :
 647             aService = Service_Swig( aService )
 648         return self.FNode( aComponent , anInterface , aService )
 649     def FNode( self , aComponent , anInterface , aService ):
 650         NodeComponent = modulecatalog.GetComponent( aComponent )
 651         aService = NodeComponent.GetService( anInterface , aService )
 652         if SuperVision.Swig :
 653             aService = Service_Swig( aService )
 654         aNode = self.G.FNode( aComponent , anInterface , aService )
 655         if aNode != None :
 656             myNode = FNode( aNode , self.G.Verbose )
 657             return myNode
 658         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 659         if self.G.Verbose :
 660             print ErrMsg
 661         return aNode
 662     def INode( self , FuncName , aPythonFunction ):
 663         aNode = self.G.INode( FuncName , aPythonFunction )
 664         if aNode != None :
 665             myNode = INode( aNode , self.G.Verbose )
 666             return myNode
 667         ErrMsg = "Failed to create a Node"
 668         if self.G.Verbose :
 669             print ErrMsg
 670             return aNode
 671     def GNode( self , FuncName , aPythonFunction , anINode ):
 672         aNode = self.G.GNode( FuncName , aPythonFunction , anINode )
 673         if aNode != None :
 674             myNode = GNode( aNode , self.G.Verbose )
 675             return myNode
 676         ErrMsg = "Failed to create a Node"
 677         if self.G.Verbose :
 678             print ErrMsg
 679             return aNode
 680     def LNode( self , InitName , InitFunction , MoreName , MoreFunction , NextName , NextFunction ):
 681         aNode,anEndOfLoop = self.G.LNode( InitName , InitFunction , MoreName , MoreFunction , NextName , NextFunction )
 682         if aNode != None :
 683             myNode = LNode( aNode , self.G.Verbose )
 684             myEndOfLoop = INode( anEndOfLoop , self.G.Verbose )
 685             return myNode,myEndOfLoop
 686         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 687         if self.G.Verbose :
 688             print ErrMsg
 689         return aNode
 690     def SNode( self , FuncName , aPythonFunction ):
 691         aNode,anEndOfSwitch = self.G.SNode( FuncName , aPythonFunction )
 692         if aNode != None :
 693             myNode = SNode( aNode , self.G.Verbose )
 694             myEndOfSwitch = INode( anEndOfSwitch , self.G.Verbose )
 695             return myNode,myEndOfSwitch
 696         ErrMsg = "Failed to create a Node"
 697         if self.G.Verbose :
 698             print ErrMsg
 699         return aNode
 700 #    def LoopNode( self , aComponent , anInterface , aService , aNodeName ):
 701 #        NodeComponent = modulecatalog.GetComponent( aComponent )
 702 #        aService = NodeComponent.GetService( anInterface , aService )
 703 #        aNode,anEndNode = self.G.LoopNode( aComponent , anInterface , aService , aNodeName )
 704 #        myNode = aNode
 705 #        myEndNode = anEndNode
 706 #        if aNode != None :
 707 #            myNode = Node( aNode , self.G.Verbose )
 708 #        if anEndNode != None :
 709 #            myEndNode = Node( anEndNode , self.G.Verbose )
 710 #        if ( aNode != None ) & ( anEndNode != None ) :
 711 #            return myNode,myEndNode
 712 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 713 #        if self.G.Verbose :
 714 #            print ErrMsg
 715 #        return aNode,anEndNode
 716 #    def SwitchNode( self , aComponent , anInterface , aService , aNodeName ):
 717 #        NodeComponent = modulecatalog.GetComponent( aComponent )
 718 #        aService = NodeComponent.GetService( anInterface , aService )
 719 #        aNode,anEndNode = self.G.SwitchNode( aComponent , anInterface , aService , aNodeName )
 720 #        myNode = aNode
 721 #        myEndNode = anEndNode
 722 #        if aNode != None :
 723 #            myNode = Node( aNode , self.G.Verbose )
 724 #        if anEndNode != None :
 725 #            myEndNode = Node( anEndNode , self.G.Verbose )
 726 #        if ( aNode != None ) & ( anEndNode != None ) :
 727 #            return myNode,myEndNode
 728 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 729 #        if self.G.Verbose :
 730 #            print ErrMsg
 731 #        return aNode,anEndNode
 732 #    def LNode( self , aNodeName ):
 733 #        aNode = self.G.LNode( aNodeName )
 734 #        if aNode != None :
 735 #            myNode = Node( aNode , self.G.Verbose )
 736 #            return myNode
 737 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 738 #        if self.G.Verbose :
 739 #            print ErrMsg
 740 #        return aNode
 741 #    def LService( self , aComponent , anInterface , aService ):
 742 #        NodeComponent = modulecatalog.GetComponent( aComponent )
 743 #        aService = NodeComponent.GetService( anInterface , aService )
 744 #        aNode = self.G.LService( aComponent , anInterface , aService )
 745 #        if aNode != None :
 746 #            myNode = Node( aNode , self.G.Verbose )
 747 #            return myNode
 748 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 749 #        if self.G.Verbose :
 750 #            print ErrMsg
 751 #        return aNode
 752 #    def CNode( self , aNodeName ):
 753 #        aNode = self.G.CNode( aNodeName )
 754 #        if aNode != None :
 755 #            myNode = Node( aNode , self.G.Verbose )
 756 #            return myNode
 757 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 758 #        if self.G.Verbose :
 759 #            print ErrMsg
 760 #        return aNode
 761 #    def CService( self , aComponent , anInterface , aService ):
 762 #        NodeComponent = modulecatalog.GetComponent( aComponent )
 763 #        aService = NodeComponent.GetService( anInterface , aService )
 764 #        aNode = self.G.CService( aComponent , anInterface , aService )
 765 #        if aNode != None :
 766 #            myNode = Node( aNode , self.G.Verbose )
 767 #            return myNode
 768 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 769 #        if self.G.Verbose :
 770 #            print ErrMsg
 771 #        return aNode
 772     def PrintService( self , aComponent , anInterface , aService ):
 773         NodeComponent = modulecatalog.GetComponent( aComponent )
 774         aService = NodeComponent.GetService( anInterface , aService )
 775         print "ServiceName ",aService.ServiceName," :"
 776         lenin = len( aService.ServiceinParameter )
 777         print "   ",lenin," input argument(s) :"
 778         i = 0
 779         while i < lenin :
 780             print "      ",i,". ",aService.ServiceinParameter[ i ].Parametername," ",aService.ServiceinParameter[ i ].Parametertype
 781             i = i + 1
 782         lenout = len( aService.ServiceoutParameter )
 783         print "   ",lenout," output argument(s) :"
 784         i = 0
 785         while i < lenout :
 786             print "      ",i,". ",aService.ServiceoutParameter[ i ].Parametername," ",aService.ServiceoutParameter[ i ].Parametertype
 787             i = i + 1
 788     def Link( self , aFromNodePort , aToNodePort ):
 789         aLink = self.G.Link( aFromNodePort.P , aToNodePort.P )
 790         if aLink != None :
 791             myLink = Link( aLink , self.G.Verbose )
 792             return myLink
 793         ErrMsg = "Failed to create a Link from " + aFromNodePort.Node().Name() + "(" + aFromNodePort.Name() + ") to " + aToNodePort.Node().Name() + "(" + aToNodePort.Name() + ")"
 794         if self.G.Verbose :
 795             print ErrMsg
 796         return aLink
 797     def Import( self , anXmlFileName ):
 798         return self.G.Import( anXmlFileName )
 799     def Export( self , anXmlFileName ):
 800         return self.G.Export( anXmlFileName )
 801     def IsReadOnly( self ) :
 802         return self.G.IsReadOnly()
 803     def ComponentRef( self , aFactoryServer , aComponent ) :
 804         return self.G.ComponentRef( aFactoryServer , aComponent )
 805     def IsValid( self ):
 806         return self.G.IsValid()
 807     def IsExecutable( self ):
 808         return self.G.IsExecutable()
 809     def IsEditing( self ):
 810         return self.G.IsEditing()
 811     def IsExecuting( self ):
 812         return self.G.IsExecuting()
 813     def LevelMax( self ):
 814         return self.G.LevelMax()
 815     def ThreadsMax( self ):
 816         return self.G.ThreadsMax()
 817     def GraphsNumber( self ):
 818         return self.G.GraphsNumber()
 819     def LevelNodes( self , aLevel ):
 820         nodes = self.G.LevelNodes( aLevel )
 821         return self.nodesTuple( nodes )
 822     def Run( self , *args ):
 823         self.S = -1
 824         aService = self.Service()
 825         nargs = len( args )
 826         i = 0
 827         while nargs > 0 :
 828             print aService.ServiceinParameter[ i ].Parametername," = ",args[i]
 829             self.Input( aService.ServiceinParameter[ i ].Parametername , args[i] )
 830             i = i + 1
 831             nargs = nargs - 1
 832         return self.G.Run()
 833     def Start( self , *args ):
 834         self.S = -1
 835         aService = self.Service()
 836         nargs = len( args )
 837         i = 0
 838         while nargs > 0 :
 839             print aService.ServiceinParameter[ i ].Parametername," = ",args[i]
 840             self.Input( aService.ServiceinParameter[ i ].Parametername , args[i] )
 841             i = i + 1
 842             nargs = nargs - 1
 843         return self.G.Start()
 844     def Event( self ):
 845         sts,aNode,anEvent,aState = self.G.Event()
 846         self.S = sts
 847         return sts,aNode,anEvent,aState
 848     def EventW( self ):
 849         sts,aNode,anEvent,aState = self.G.EventW()
 850         self.S = sts
 851         return sts,aNode,anEvent,aState
 852     def NextW( self ):
 853         if self.S != 0 :
 854             sts,aNode,anEvent,aState = self.G.EventW()
 855             self.S = sts
 856             print sts,aNode.Thread(),aNode.SubGraph(),aNode.Name(),anEvent,aState
 857         return sts
 858     def Threads( self ):
 859         return self.G.Threads()
 860     def SuspendedThreads( self ):
 861         return self.G.SuspendedThreads()
 862     def LastLevelDone( self ):
 863         return self.G.LastLevelDone()
 864     def Verbose( self , verbose ):
 865         preverbose = self.G.Verbose
 866         self.G.Verbose = verbose
 867         return preverbose
 868     def Nodes( self ):
 869         nodes = self.G.Nodes()
 870         return self.nodesTuple( nodes )
 871     def nodesTuple( self , nodes ) :
 872         n = len( nodes.CNodes )
 873         i = 0
 874         j = 0
 875         pynodes = []
 876         while i < n :
 877             pynodes.append( CNode( nodes.CNodes[i] , self.G.Verbose ) )
 878             i = i + 1
 879             j = j + 1
 880         n = len( nodes.FNodes )
 881         i = 0
 882         while i < n :
 883             pynodes.append( FNode( nodes.FNodes[i] , self.G.Verbose ) )
 884             i = i + 1
 885             j = j + 1
 886         n = len( nodes.INodes )
 887         i = 0
 888         while i < n :
 889             pynodes.append( INode( nodes.INodes[i] , self.G.Verbose ) )
 890             i = i + 1
 891             j = j + 1
 892         n = len( nodes.GNodes )
 893         i = 0
 894         while i < n :
 895             pynodes.append( GNode( nodes.GNodes[i] , self.G.Verbose ) )
 896             i = i + 1
 897             j = j + 1
 898         n = len( nodes.LNodes )
 899         i = 0
 900         while i < n :
 901             pynodes.append( LNode( nodes.LNodes[i] , self.G.Verbose ) )
 902             i = i + 1
 903             j = j + 1
 904         n = len( nodes.ELNodes )
 905         i = 0
 906         while i < n :
 907             pynodes.append( GNode( nodes.ELNodes[i] , self.G.Verbose ) )
 908             i = i + 1
 909             j = j + 1
 910         n = len( nodes.SNodes )
 911         i = 0
 912         while i < n :
 913             pynodes.append( SNode( nodes.SNodes[i] , self.G.Verbose ) )
 914             i = i + 1
 915             j = j + 1
 916         n = len( nodes.ESNodes )
 917         i = 0
 918         while i < n :
 919             pynodes.append( GNode( nodes.ESNodes[i] , self.G.Verbose ) )
 920             i = i + 1
 921             j = j + 1
 922         return pynodes
 923     def ListNodes( self , *args ):
 924         nodes = self.Nodes()
 925         listofnodes = ""
 926         if len( nodes ) :
 927             listofnodes = nodes[ 0 ].Name()
 928             i = 1
 929             while i < len( nodes ) :
 930                 listofnodes = listofnodes + ',' + nodes[ i ].Name()
 931                 i = i + 1
 932         print listofnodes
 933         if len( args ) == 0 :
 934             aName = self.N.Name()
 935         else :
 936             aName = args[ 0 ]
 937         if len( nodes ) == 1 :
 938             listofnodes = "[" + listofnodes + "] = " + aName + ".Nodes()"
 939         else :
 940             listofnodes = listofnodes + " = " + aName + ".Nodes()"
 941         return listofnodes
 942     def PrintNodes( self ):
 943         nodes = self.Nodes()
 944         n = len( nodes )
 945         i = 0
 946         while i < n :
 947             print ' '
 948             nodes[i].Print()
 949             i = i + 1
 950     def PrintThreads( self ):
 951         nodes = self.Nodes()
 952         i = 0
 953         while i < len( nodes ) :
 954             print nodes[i].Name(),nodes[i].Thread(),nodes[i].State(),nodes[i].Control(),nodes[i].AutoState()
 955             i = i + 1
 956     def GLinks( self ):
 957         links = self.G.GLinks()
 958         i = 0
 959         while i < len( links ) :
 960             links[ i ] = Link( links[i] , self.G.Verbose )
 961             i = i + 1
 962         return links
 963     def ListLinks( self , *args ):
 964         links = self.G.GLinks()
 965         if len( links ) :
 966             listoflinks = links[ 0 ].InPort().Node().Name()
 967             listoflinks = listoflinks + links[ 0 ].InPort().Name()
 968             i = 1
 969             while i < len( links ) :
 970                 listoflinks = listoflinks + ',' + links[ i ].InPort().Node().Name()
 971                 listoflinks = listoflinks + links[ i ].InPort().Name()
 972                 i = i + 1
 973         print listoflinks
 974         if len( args ) == 0 :
 975             aName = self.N.Name()
 976         else :
 977             aName = args[ 0 ]
 978         if len( links ) == 1 :
 979             listoflinks = "[" + listoflinks + "] = " + aName + ".GLinks()"
 980         else :
 981             listoflinks = listoflinks + " = " + aName + ".GLinks()"
 982         return listoflinks
 983     def PrintLinks( self ):
 984         links = self.G.GLinks()
 985         i = 0
 986         while i < len( links ) :
 987             Link( links[ i ] , self.G.Verbose ).Print()
 988             i = i + 1
 989     def Graphs( self ):
 990         graphs = self.G.Graphs()
 991         outgraphs = graphs
 992         i = 0
 993         while i < len( graphs ) :
 994             outgraphs[ i ] = Graph( graphs[i].Name() , self.G.Verbose )
 995             outgraphs[ i ].Merge( graphs[i] )
 996             i = i + 1
 997         return outgraphs
 998     def Copy( self ):
 999         aCopy = self.G.Copy()
1000         if aCopy != None:
1001             myCopy = Graph( aCopy )
1002             return myCopy
1003         ErrMsg = "Failed to get a Copy of " + self.G.Name()
1004         if self.G.Verbose :
1005             print ErrMsg
1006         return aCopy
1007     def Merge( self , aGraph ):
1008         return self.G.Merge( aGraph.G )
1009     def Destroy( self ):
1010         self.N.destroy()
1011
1012 ##########################################################
1013 class GraphE(Graph):
1014 ##########################################################
1015     def __init__( self , aName ):
1016         graph = SuperVision.GraphE( aName )
1017         self.G = graph
1018         self.G.Verbose = 1
1019         self.N = graph
1020         self.N.Verbose = 1
1021
1022 ##########################################################
1023 class Value:
1024 ##########################################################
1025     def __init__( self , aValue , Verbose ):
1026         self.V = aValue
1027         self.V.Verbose = Verbose
1028     def ToString( self ):
1029         return self.V.ToString()
1030     def ToAny( self ):
1031         return self.V.ToAny()
1032     def Destroy( self ):
1033         self.N.destroy()
1034
1035 ##########################################################
1036 class Port:
1037 ##########################################################
1038     def __init__( self , aPort , Verbose ):
1039         self.P = aPort
1040         self.P.Verbose = Verbose
1041     def Input( self , *args ):
1042         types, realargs = getRealArgs(self.P,args)
1043         fn = bs_AddInput_valuedict[types]
1044         anInput = apply( fn, realargs)
1045         return anInput
1046     def Node( self ):
1047         aNode = self.P.Node()
1048         if aNode != None :
1049             if aNode.IsComputing() :
1050                 myNode = CNode( aNode , self.P.Verbose )
1051             elif aNode.IsFactory() :
1052                 myNode = FNode( aNode , self.P.Verbose )
1053             elif aNode.IsInLine() :
1054                 myNode = INode( aNode , self.P.Verbose )
1055             elif aNode.IsGOTO() :
1056                 myNode = GNode( aNode , self.P.Verbose )
1057             elif aNode.IsLoop() :
1058                 myNode = LNode( aNode , self.P.Verbose )
1059             elif aNode.IsEndLoop() :
1060                 myNode = ELNode( aNode , self.P.Verbose )
1061             elif aNode.IsSwitch() :
1062                 myNode = SNode( aNode , self.P.Verbose )
1063             elif aNode.IsEndSwitch() :
1064                 myNode = ESNode( aNode , self.P.Verbose )
1065             else :
1066                 myNode = None
1067             return myNode
1068         return aNode
1069     def Name( self ):
1070         return self.P.Name()
1071     def Type( self ):
1072         return self.P.Type()
1073     def Link( self ):
1074         aLink = self.P.Link()
1075         if aLink != None :
1076             myLink = Link( aLink , self.P.Verbose )
1077             return myLink
1078         ErrMsg = "Failed to get a Link to " + self.P.Node().Name() + "(" + self.P.Name() + ")"
1079         if self.P.Verbose :
1080             print ErrMsg
1081         return aLink
1082     def Links( self ):
1083         links = self.P.Links()
1084         i = 0
1085         while i < len( links ) :
1086             links[ i ] = Link( links[i] , self.P.Verbose )
1087             i = i + 1
1088         return links
1089     def PrintLinks( self ):
1090         links = self.P.Links()
1091         i = 0
1092         while i < len( links ) :
1093             Link( links[ i ] , self.P.Verbose ).Print()
1094             i = i + 1
1095     def IsInput( self ):
1096         return self.P.IsInput()
1097     def IsLinked( self ):
1098         return self.P.IsLinked()
1099     def HasInput( self ):
1100         return self.P.HasInput()
1101     def Kind( self ) :
1102         return self.P.Kind()
1103     def IsParam( self ):
1104         return self.P.IsParam()
1105     def IsGate( self ):
1106         return self.P.IsGate()
1107     def IsLoop( self ):
1108         return self.P.IsLoop()
1109     def IsInLine( self ):
1110         return self.P.IsInLine()
1111     def IsSwitch( self ):
1112         return self.P.IsSwitch()
1113     def IsEndSwitch( self ):
1114         return self.P.IsEndSwitch()
1115 #    def IsBus( self ):
1116 #        return self.P.IsBus()
1117     def Done( self ):
1118         return self.P.Done()
1119     def State( self ):
1120         return self.P.State()
1121     def ToString( self ):
1122         return self.P.ToString()
1123     def ToAny( self ):
1124         return self.P.ToAny()
1125     def Print( self ):
1126         if self.P.IsInput() :
1127             if self.P.IsLinked() :
1128                 print "In",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString(),' from ',self.Link().OutPort().Print()
1129             else :
1130                 print "In",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString()
1131         else :
1132             print "Out",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString()
1133     def Destroy( self ):
1134         self.P.destroy()
1135
1136 ##########################################################
1137 class Link:
1138 ##########################################################
1139     def __init__( self , aLink , Verbose ):
1140         self.L = aLink
1141         self.L.Verbose = Verbose
1142     def OutPort( self ):
1143         aPort = self.L.OutPort()
1144         if aPort != None :
1145             myPort = Port( aPort , self.L.Verbose )
1146             return myPort
1147         if self.L.Verbose :
1148             print "Error while getting the Port : "
1149         return None
1150     def InPort( self ):
1151         aPort = self.L.InPort()
1152         if aPort != None :
1153             myPort = Port( aPort , self.L.Verbose )
1154             return myPort
1155         if self.L.Verbose :
1156             print "Error while getting the Port : "
1157         return None
1158     def Print( self ):
1159         anOutPort = self.L.OutPort()
1160         anInPort = self.L.InPort()
1161         print anOutPort.Node().Name(),'(',anOutPort.Name(),' ',anOutPort.Kind(),') =',anOutPort.ToString(),' --> ',anInPort.Node().Name(),'(',anInPort.Name(),')',' ',anInPort.Kind()
1162     def CoordsSize( self ):
1163         return self.L.CoordsSize()
1164     def AddCoord( self , index , X , Y ):
1165         return self.L.AddCoord( index , X , Y )
1166     def ChangeCoord( self , index , X , Y ):
1167         return self.L.ChangeCoord( index , X , Y )
1168     def RemoveCoord( self , index ):
1169         return self.L.RemoveCoord( index )
1170     def Coords( self , index ):
1171         return self.L.Coords( index )
1172     def destroy( self ):
1173         self.L.destroy()
1174
1175