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