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