src/Supervision/batchmode_SuperV.py

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