src/Supervision/batchmode_SuperV.py

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