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