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         print types,realargs,fn
 248         anInput = apply( fn, realargs)
 249         if anInput != None :
 250             myInput = Port( anInput , self.N.Verbose )
 251             return myInput
 252         ErrMsg = "Failed to create the Input"
 253         if self.N.Verbose :
 254             print ErrMsg
 255         return anInput
 256 #    def BusPort( self , InOutParameterName , InOutParameterType ):
 257 #        sts,inp,outp = self.N.BusPort( InOutParameterName ,
 258 #                                       InOutParameterType )
 259 #        inp = Port( inp , self.N.Verbose )
 260 #        outp = Port( outp , self.N.Verbose )
 261 #        return sts,inp,outp
 262 #    def BusPorts( self , InputParameterName , InputParameterType ,
 263 #                  OutputParameterName , OutputParameterType ):
 264 #        sts,inp,outp = self.N.BusPorts( InputParameterName ,
 265 #                                        InputParameterType ,
 266 #                                        OutputParameterName ,
 267 #                                        OutputParameterType )
 268 #        inp = Port( inp , self.N.Verbose )
 269 #        outp = Port( outp , self.N.Verbose )
 270 #        return sts,inp,outp
 271     def Ports( self ):
 272         ports = self.N.Ports()
 273         i = 0
 274         while i < len( ports ) :
 275             ports[ i ] = Port( ports[i] , self.N.Verbose )
 276             i = i + 1
 277         return ports
 278     def ListPorts( self , *args ):
 279         if len( args ) == 0 :
 280             aName = self.N.Name()
 281         else :
 282             aName = args[ 0 ]
 283         ports = self.N.Ports()
 284         listofports = ""
 285         if len( ports ) :
 286             portsname = ports[ 0 ].Name()
 287             bs = portsname.find('\\')
 288             if bs != -1 :
 289                 portsname1,portsname2 = portsname.split('\\')
 290                 portsname = portsname1 + portsname2
 291             if ports[ 0 ].IsInput():
 292                 listofports = aName + 'In' + portsname
 293             else :
 294                 listofports = aName + 'Out' + portsname
 295             i = 1
 296             while i < len( ports ) :
 297                 portsname = ports[ i ].Name()
 298                 bs = portsname.find('\\')
 299                 if bs != -1 :
 300                     portsname1,portsname2 = portsname.split('\\')
 301                     portsname = portsname1 + portsname2
 302                 if ports[ i ].IsInput():
 303                     listofports = listofports + ',' + aName + 'In' + portsname
 304                 else :
 305                     listofports = listofports + ',' + aName + 'Out' + portsname
 306                 i = i + 1
 307         print listofports
 308         if len( ports ) == 1 :
 309             listofports = "[" + listofports + "] = " + aName + ".Ports()"
 310         else :
 311             listofports = listofports + " = " + aName + ".Ports()"
 312         return listofports
 313     def PrintPorts( self ):
 314         ports = self.N.Ports()
 315         i = 0
 316         while i < len( ports ) :
 317             Direction = "Out"
 318             if ports[ i ].IsInput() :
 319                 Direction = "In"
 320             print Direction,self.N.Name(),'(',ports[ i ].Name(),ports[ i ].Kind(),ports[ i ].Type(),') = ',ports[ i ].ToString()
 321             i = i + 1
 322     def Links( self ) :
 323         links = self.N.Links()
 324         i = 0
 325         while i < len( links ) :
 326             links[ i ] = Link( links[i] , self.N.Verbose )
 327             i = i + 1
 328         return links
 329     def PrintLinks( self ):
 330         links = self.Links()
 331         i = 0
 332         while i < len( links ) :
 333             links[i].Print()
 334             i = i + 1
 335     def IsGraph( self ):
 336         return self.N.IsGraph()
 337     def IsComputing( self ):
 338         return self.N.IsComputing()
 339     def IsFactory( self ):
 340         return self.N.IsFactory()
 341     def IsInLine( self ):
 342         return self.N.IsInLine()
 343     def IsGOTO( self ):
 344         return self.N.IsGOTO()
 345     def IsLoop( self ):
 346         return self.N.IsLoop()
 347     def IsEndLoop( self ):
 348         return self.N.IsEndLoop()
 349     def IsSwitch( self ):
 350         return self.N.IsSwitch()
 351     def IsEndSwitch( self ):
 352         return self.N.IsEndSwitch()
 353     def SubGraph( self ):
 354         return self.N.SubGraph()
 355     def Thread( self ):
 356         return self.N.Thread()
 357     def IsWaiting( self ):
 358         return self.N.IsWaiting()
 359     def IsRunning( self ):
 360         return self.N.IsRunning()
 361     def IsDone( self ):
 362         return self.N.IsDone()
 363     def IsSuspended( self ):
 364         return self.N.IsSuspended()
 365     def State( self ):
 366         return self.N.State()
 367     def Control( self ):
 368         return self.N.Control()
 369     def ControlClear( self ):
 370         return self.N.ControlClear()
 371     def AutoState( self ):
 372         return self.N.AutoState()
 373     def ReadyW( self ):
 374         return self.N.ReadyW()
 375     def RunningW( self ):
 376         return self.N.RunningW()
 377     def DoneW( self ):
 378         return self.N.DoneW()
 379     def SuspendedW( self ):
 380         return self.N.SuspendedW()
 381     def ReRun( self ):
 382         return self.N.ReRun()
 383     def ReStart( self ):
 384         return self.N.ReStart()
 385     def ReRunAt( self , aNodeName ):
 386         return self.N.ReRunAt( aNodeName )
 387     def ReStartAt( self , aNodeName ):
 388         return self.N.ReStartAt( aNodeName )
 389     def Ping( self ):
 390         return self.N.ping()
 391     def Kill( self ):
 392         return self.N.Kill()
 393     def KillDone( self ):
 394         return self.N.KillDone()
 395     def Suspend( self ):
 396         return self.N.Suspend()
 397     def SuspendDone( self ):
 398         return self.N.SuspendDone()
 399     def Resume( self ):
 400         return self.N.Resume()
 401     def Stop( self ):
 402         return self.N.Stop()
 403     def Coords( self , X , Y ):
 404         return self.N.Coords( X , Y )
 405     def X( self ):
 406         return self.N.X()
 407     def Y( self ):
 408         return self.N.Y()
 409     def destroy( self ):
 410         self.N.destroy()
 411     def CpuUsed( self ):
 412         return self.N.CpuUsed()
 413
 414 ##########################################################
 415 class FNode(CNode):
 416 ##########################################################
 417     def __init__( self , aNode , Verbose ):
 418         self.N = aNode
 419         self.N.Verbose = Verbose
 420     def GetComponentName( self ):
 421         return self.N.GetComponentName()
 422     def GetInterfaceName( self ):
 423         return self.N._get_interfaceName()
 424     def GetContainer( self ):
 425         return self.N.GetContainer()
 426     def SetComponentName( self , aComponentName ):
 427         return self.N.SetComponentName( aComponentName )
 428     def SetInterfaceName( self , anInterfaceName ):
 429         return self.N.SetInterfaceName( anInterfaceName )
 430     def SetContainer( self , aComputer ):
 431         return self.N.SetContainer( aComputer )
 432
 433 ##########################################################
 434 class INode(CNode):
 435 ##########################################################
 436     def __init__( self , aNode , Verbose ):
 437         self.N = aNode
 438         self.N.Verbose = Verbose
 439     def Edit( self , FuncName , PyFunc ) :
 440         import os
 441         import random
 442         suf = str(random.randrange(1,10000))
 443         file = '/tmp/' + FuncName + '_' + suf + '.py'
 444         try :
 445             #d = dir ()
 446             #print "dir()",d
 447             fd = os.open( file , os.O_CREAT | os.O_WRONLY | os.O_TRUNC )
 448             #d = dir (fd)
 449             #print "dir(fd)",d
 450             i = 0
 451             while ( i < len( PyFunc ) ) :
 452                 print i,'/',len( PyFunc ),PyFunc[ i ]
 453                 os.write( fd , PyFunc[ i ] + '\n' )
 454                 i = i + 1
 455             os.close( fd )
 456             edit = '${EDITOR} ' + file
 457             os.system( edit )
 458             fd = os.open( file , os.O_RDONLY )
 459             line = os.read( fd , 132 )
 460             res = ''
 461             while len( line ) :
 462                 res = res + line
 463                 line = os.read( fd , 132 )
 464             os.close( fd )
 465             PyFunc = res.splitlines()
 466             i = 0
 467             while i < len( PyFunc ) :
 468                 print PyFunc[i]
 469                 i = i + 1
 470         except :
 471             print "Open of",file,"failed."
 472         return PyFunc
 473     def SetPyFunction( self , FuncName , aPyFunction ):
 474         return self.N.SetPyFunction( FuncName , aPyFunction )
 475     def PyFunction( self ):
 476         return self.N.PyFunction()
 477     def PyFuncName( self ):
 478         return self.N.PyFuncName()
 479     def EPyFunc( self ):
 480         PyFunc = self.N.PyFunction()
 481         PyFunc = self.Edit( self.N.PyFuncName() , PyFunc )
 482         self.N.SetPyFunction( self.N.PyFuncName() , PyFunc )
 483     def InPort( self , aParameterName , aParameterType ):
 484         aPort = self.N.InPort( aParameterName ,
 485                              aParameterType )
 486         if aPort != None :
 487             myPort = Port( aPort , self.N.Verbose )
 488             return myPort
 489         if self.N.Verbose :
 490             print "Error while creating the Port : ",aParameterName
 491         return None
 492     def OutPort( self , aParameterName , aParameterType ):
 493         aPort = self.N.OutPort( 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
 502 ##########################################################
 503 class GNode(INode):
 504 ##########################################################
 505     def __init__( self , aNode , Verbose ):
 506         self.N = aNode
 507         self.N.Verbose = Verbose
 508     def SetCoupled( self , anInLineNode ):
 509         if self.N.IsGOTO() :
 510             node = self.N.SetCoupled( anInLineNode )
 511         else :
 512             node = None
 513         return node
 514     def Coupled( self ):
 515         node = self.N.Coupled()
 516         if node != None :
 517             if node.IsInLine() :
 518                 node = INode( node , self.N.Verbose )
 519             elif node.IsLoop() :
 520                 node = LNode( node , self.N.Verbose )
 521             elif node.IsEndLoop() :
 522                 node = ELNode( node , self.N.Verbose )
 523             elif node.IsSwitch() :
 524                 node = SNode( node , self.N.Verbose )
 525             elif node.IsEndSwitch() :
 526                 node = ESNode( node , self.N.Verbose )
 527         return node
 528
 529 ##########################################################
 530 class LNode(GNode):
 531 ##########################################################
 532     def __init__( self , aNode , Verbose ):
 533         self.N = aNode
 534         self.N.Verbose = Verbose
 535     def SetPyInit( self , InitName , aPyFunction ):
 536         return self.N.SetPyInit( InitName , aPyFunction )
 537     def PyInit( self ):
 538         return self.N.PyInit()
 539     def PyInitName( self ) :
 540         return self.N.PyInitName()
 541     def EPyInit( self ):
 542         PyFunc = self.N.PyFunction()
 543         PyFunc = self.Edit( self.N.PyFuncName() , PyFunc )
 544         self.N.SetPyFunction( self.N.PyFuncName() , PyFunc )
 545     def SetPyMore( self , MoreName , aPyFunction ):
 546         return self.N.SetPyMore( MoreName , aPyFunction )
 547     def PyMore( self ):
 548         return self.N.PyMore()
 549     def PyMoreName( self ) :
 550         return self.N.PyMoreName()
 551     def EPyMore( self ):
 552         PyMore = self.N.PyMore()
 553         PyMore = self.Edit( self.N.PyMoreName() , PyMore )
 554         self.N.SetPyMore( self.N.PyMoreName() , PyMore )
 555     def SetPyNext( self , NextName , aPyFunction ):
 556         return self.N.SetPyNext( NextName , aPyFunction )
 557     def PyNext( self ):
 558         return self.N.PyNext()
 559     def PyNextName( self ) :
 560         return self.N.PyNextName()
 561     def EPyNext( self ):
 562         PyNext = self.N.PyNext()
 563         PyNext = self.Edit( self.N.PyNextName() , PyNext )
 564         self.N.SetPyNext( self.N.PyNextName() , PyNext )
 565
 566 ##########################################################
 567 class ELNode(GNode):
 568 ##########################################################
 569     def __init__( self , aNode , Verbose ):
 570         self.N = aNode
 571         self.N.Verbose = Verbose
 572
 573 ##########################################################
 574 class SNode(GNode):
 575 ##########################################################
 576     def __init__( self , aNode , Verbose ):
 577         self.N = aNode
 578         self.N.Verbose = Verbose
 579
 580 ##########################################################
 581 class ESNode(GNode):
 582 ##########################################################
 583     def __init__( self , aNode , Verbose ):
 584         self.N = aNode
 585         self.N.Verbose = Verbose
 586
 587 ##########################################################
 588 #class ServicesParameter_Swig :
 589 ##########################################################
 590 #    def __init__( self , aServicesParameter ):
 591 #        self.Parametertype = aServicesParameter.Parametertype
 592 #        self.Parametername = aServicesParameter.Parametername
 593
 594 ##########################################################
 595 class Graph(INode):
 596 ##########################################################
 597     def __init__( self , aName ):
 598         try:
 599             graph = SuperVision.Graph( aName )
 600         except:
 601             try:
 602                 graph = aName.G.Copy()
 603             except:
 604                 graph = None
 605         if graph != None :
 606             self.G = graph
 607             self.G.Verbose = 1
 608             self.N = graph
 609             self.N.Verbose = 1
 610         else :
 611             print "Graph creation failed"
 612     def CNode( self , *args ):
 613         if len( args ) == 1 :
 614             aService = args[ 0 ]
 615         else :
 616             aComponent = args[ 0 ]
 617             anInterface = args[ 1 ]
 618             aService = args[ 2 ]
 619             NodeComponent = modulecatalog.GetComponent( aComponent )
 620             aService = NodeComponent.GetService( anInterface , aService )
 621         aNode = self.G.CNode( aService )
 622         if aNode != None :
 623             myNode = CNode( aNode , self.G.Verbose )
 624             return myNode
 625         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 626         if self.G.Verbose :
 627             print ErrMsg
 628         return aNode
 629     def Node( self , aComponent , anInterface , aService ):
 630         if SuperVision.Swig :
 631             aService = Service_Swig( aService )
 632         return self.FNode( aComponent , anInterface , aService )
 633     def FNode( self , aComponent , anInterface , aService ):
 634         NodeComponent = modulecatalog.GetComponent( aComponent )
 635         aService = NodeComponent.GetService( anInterface , aService )
 636         if SuperVision.Swig :
 637             aService = Service_Swig( aService )
 638         aNode = self.G.FNode( aComponent , anInterface , aService )
 639         if aNode != None :
 640             myNode = FNode( aNode , self.G.Verbose )
 641             return myNode
 642         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 643         if self.G.Verbose :
 644             print ErrMsg
 645         return aNode
 646     def INode( self , FuncName , aPythonFunction ):
 647         aNode = self.G.INode( FuncName , aPythonFunction )
 648         if aNode != None :
 649             myNode = INode( aNode , self.G.Verbose )
 650             return myNode
 651         ErrMsg = "Failed to create a Node"
 652         if self.G.Verbose :
 653             print ErrMsg
 654             return aNode
 655     def GNode( self , FuncName , aPythonFunction , anINode ):
 656         aNode = self.G.GNode( FuncName , aPythonFunction , anINode )
 657         if aNode != None :
 658             myNode = GNode( 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 LNode( self , InitName , InitFunction , MoreName , MoreFunction , NextName , NextFunction ):
 665         aNode,anEndOfLoop = self.G.LNode( InitName , InitFunction , MoreName , MoreFunction , NextName , NextFunction )
 666         if aNode != None :
 667             myNode = LNode( aNode , self.G.Verbose )
 668             myEndOfLoop = INode( anEndOfLoop , self.G.Verbose )
 669             return myNode,myEndOfLoop
 670         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 671         if self.G.Verbose :
 672             print ErrMsg
 673         return aNode
 674     def SNode( self , FuncName , aPythonFunction ):
 675         aNode,anEndOfSwitch = self.G.SNode( FuncName , aPythonFunction )
 676         if aNode != None :
 677             myNode = SNode( aNode , self.G.Verbose )
 678             myEndOfSwitch = INode( anEndOfSwitch , self.G.Verbose )
 679             return myNode,myEndOfSwitch
 680         ErrMsg = "Failed to create a Node"
 681         if self.G.Verbose :
 682             print ErrMsg
 683         return aNode
 684 #    def LoopNode( self , aComponent , anInterface , aService , aNodeName ):
 685 #        NodeComponent = modulecatalog.GetComponent( aComponent )
 686 #        aService = NodeComponent.GetService( anInterface , aService )
 687 #        aNode,anEndNode = self.G.LoopNode( aComponent , anInterface , aService , aNodeName )
 688 #        myNode = aNode
 689 #        myEndNode = anEndNode
 690 #        if aNode != None :
 691 #            myNode = Node( aNode , self.G.Verbose )
 692 #        if anEndNode != None :
 693 #            myEndNode = Node( anEndNode , self.G.Verbose )
 694 #        if ( aNode != None ) & ( anEndNode != None ) :
 695 #            return myNode,myEndNode
 696 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 697 #        if self.G.Verbose :
 698 #            print ErrMsg
 699 #        return aNode,anEndNode
 700 #    def SwitchNode( self , aComponent , anInterface , aService , aNodeName ):
 701 #        NodeComponent = modulecatalog.GetComponent( aComponent )
 702 #        aService = NodeComponent.GetService( anInterface , aService )
 703 #        aNode,anEndNode = self.G.SwitchNode( aComponent , anInterface , aService , aNodeName )
 704 #        myNode = aNode
 705 #        myEndNode = anEndNode
 706 #        if aNode != None :
 707 #            myNode = Node( aNode , self.G.Verbose )
 708 #        if anEndNode != None :
 709 #            myEndNode = Node( anEndNode , self.G.Verbose )
 710 #        if ( aNode != None ) & ( anEndNode != None ) :
 711 #            return myNode,myEndNode
 712 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 713 #        if self.G.Verbose :
 714 #            print ErrMsg
 715 #        return aNode,anEndNode
 716 #    def LNode( self , aNodeName ):
 717 #        aNode = self.G.LNode( aNodeName )
 718 #        if aNode != None :
 719 #            myNode = Node( aNode , self.G.Verbose )
 720 #            return myNode
 721 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 722 #        if self.G.Verbose :
 723 #            print ErrMsg
 724 #        return aNode
 725 #    def LService( self , aComponent , anInterface , aService ):
 726 #        NodeComponent = modulecatalog.GetComponent( aComponent )
 727 #        aService = NodeComponent.GetService( anInterface , aService )
 728 #        aNode = self.G.LService( aComponent , anInterface , aService )
 729 #        if aNode != None :
 730 #            myNode = Node( aNode , self.G.Verbose )
 731 #            return myNode
 732 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 733 #        if self.G.Verbose :
 734 #            print ErrMsg
 735 #        return aNode
 736 #    def CNode( self , aNodeName ):
 737 #        aNode = self.G.CNode( aNodeName )
 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 CService( self , aComponent , anInterface , aService ):
 746 #        NodeComponent = modulecatalog.GetComponent( aComponent )
 747 #        aService = NodeComponent.GetService( anInterface , aService )
 748 #        aNode = self.G.CService( aComponent , anInterface , aService )
 749 #        if aNode != None :
 750 #            myNode = Node( aNode , self.G.Verbose )
 751 #            return myNode
 752 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 753 #        if self.G.Verbose :
 754 #            print ErrMsg
 755 #        return aNode
 756     def PrintService( self , aComponent , anInterface , aService ):
 757         NodeComponent = modulecatalog.GetComponent( aComponent )
 758         aService = NodeComponent.GetService( anInterface , aService )
 759         print "ServiceName ",aService.ServiceName," :"
 760         lenin = len( aService.ServiceinParameter )
 761         print "   ",lenin," input argument(s) :"
 762         i = 0
 763         while i < lenin :
 764             print "      ",i,". ",aService.ServiceinParameter[ i ].Parametername," ",aService.ServiceinParameter[ i ].Parametertype
 765             i = i + 1
 766         lenout = len( aService.ServiceoutParameter )
 767         print "   ",lenout," output argument(s) :"
 768         i = 0
 769         while i < lenout :
 770             print "      ",i,". ",aService.ServiceoutParameter[ i ].Parametername," ",aService.ServiceoutParameter[ i ].Parametertype
 771             i = i + 1
 772     def Link( self , aFromNodePort , aToNodePort ):
 773         aLink = self.G.Link( aFromNodePort.P , aToNodePort.P )
 774         if aLink != None :
 775             myLink = Link( aLink , self.G.Verbose )
 776             return myLink
 777         ErrMsg = "Failed to create a Link from " + aFromNodePort.Node().Name() + "(" + aFromNodePort.Name() + ") to " + aToNodePort.Node().Name() + "(" + aToNodePort.Name() + ")"
 778         if self.G.Verbose :
 779             print ErrMsg
 780         return aLink
 781     def Import( self , anXmlFileName ):
 782         return self.G.Import( anXmlFileName )
 783     def Export( self , anXmlFileName ):
 784         return self.G.Export( anXmlFileName )
 785     def IsReadOnly( self ) :
 786         return self.G.IsReadOnly()
 787     def ComponentRef( self , aFactoryServer , aComponent ) :
 788         return self.G.ComponentRef( aFactoryServer , aComponent )
 789     def IsValid( self ):
 790         return self.G.IsValid()
 791     def IsExecutable( self ):
 792         return self.G.IsExecutable()
 793     def IsEditing( self ):
 794         return self.G.IsEditing()
 795     def IsExecuting( self ):
 796         return self.G.IsExecuting()
 797     def LevelMax( self ):
 798         return self.G.LevelMax()
 799     def ThreadsMax( self ):
 800         return self.G.ThreadsMax()
 801     def GraphsNumber( self ):
 802         return self.G.GraphsNumber()
 803     def LevelNodes( self , aLevel ):
 804         nodes = self.G.LevelNodes( aLevel )
 805         return self.nodesTuple( nodes )
 806     def Run( self , *args ):
 807         self.S = -1
 808         aService = self.Service()
 809         nargs = len( args )
 810         i = 0
 811         while nargs > 0 :
 812             print aService.ServiceinParameter[ i ].Parametername," = ",args[i]
 813             self.Input( aService.ServiceinParameter[ i ].Parametername , args[i] )
 814             i = i + 1
 815             nargs = nargs - 1
 816         return self.G.Run()
 817     def Start( self , *args ):
 818         self.S = -1
 819         aService = self.Service()
 820         nargs = len( args )
 821         i = 0
 822         while nargs > 0 :
 823             print aService.ServiceinParameter[ i ].Parametername," = ",args[i]
 824             self.Input( aService.ServiceinParameter[ i ].Parametername , args[i] )
 825             i = i + 1
 826             nargs = nargs - 1
 827         return self.G.Start()
 828     def Event( self ):
 829         sts,aNode,anEvent,aState = self.G.Event()
 830         self.S = sts
 831         return sts,aNode,anEvent,aState
 832     def EventNoW( self ):
 833         sts,aNode,anEvent,aState = self.G.EventNoW()
 834         self.S = sts
 835         return sts,aNode,anEvent,aState
 836     def EventW( self ):
 837         sts,aNode,anEvent,aState = self.G.EventW()
 838         self.S = sts
 839         return sts,aNode,anEvent,aState
 840     def NextW( self ):
 841         if self.S != 0 :
 842             sts,aNode,anEvent,aState = self.G.EventW()
 843             self.S = sts
 844             print sts,aNode.Thread(),aNode.SubGraph(),aNode.Name(),anEvent,aState
 845         return sts
 846     def Threads( self ):
 847         return self.G.Threads()
 848     def SuspendedThreads( self ):
 849         return self.G.SuspendedThreads()
 850     def LastLevelDone( self ):
 851         return self.G.LastLevelDone()
 852     def Verbose( self , verbose ):
 853         preverbose = self.G.Verbose
 854         self.G.Verbose = verbose
 855         return preverbose
 856     def Nodes( self ):
 857         nodes = self.G.Nodes()
 858         return self.nodesTuple( nodes )
 859     def nodesTuple( self , nodes ) :
 860         n = len( nodes.CNodes )
 861         i = 0
 862         j = 0
 863         pynodes = []
 864         while i < n :
 865             pynodes.append( CNode( nodes.CNodes[i] , self.G.Verbose ) )
 866             i = i + 1
 867             j = j + 1
 868         n = len( nodes.FNodes )
 869         i = 0
 870         while i < n :
 871             pynodes.append( FNode( nodes.FNodes[i] , self.G.Verbose ) )
 872             i = i + 1
 873             j = j + 1
 874         n = len( nodes.INodes )
 875         i = 0
 876         while i < n :
 877             pynodes.append( INode( nodes.INodes[i] , self.G.Verbose ) )
 878             i = i + 1
 879             j = j + 1
 880         n = len( nodes.GNodes )
 881         i = 0
 882         while i < n :
 883             pynodes.append( GNode( nodes.GNodes[i] , self.G.Verbose ) )
 884             i = i + 1
 885             j = j + 1
 886         n = len( nodes.LNodes )
 887         i = 0
 888         while i < n :
 889             pynodes.append( LNode( nodes.LNodes[i] , self.G.Verbose ) )
 890             i = i + 1
 891             j = j + 1
 892         n = len( nodes.ELNodes )
 893         i = 0
 894         while i < n :
 895             pynodes.append( GNode( nodes.ELNodes[i] , self.G.Verbose ) )
 896             i = i + 1
 897             j = j + 1
 898         n = len( nodes.SNodes )
 899         i = 0
 900         while i < n :
 901             pynodes.append( SNode( nodes.SNodes[i] , self.G.Verbose ) )
 902             i = i + 1
 903             j = j + 1
 904         n = len( nodes.ESNodes )
 905         i = 0
 906         while i < n :
 907             pynodes.append( GNode( nodes.ESNodes[i] , self.G.Verbose ) )
 908             i = i + 1
 909             j = j + 1
 910         return pynodes
 911     def ListNodes( self , *args ):
 912         nodes = self.Nodes()
 913         listofnodes = ""
 914         if len( nodes ) :
 915             listofnodes = nodes[ 0 ].Name()
 916             i = 1
 917             while i < len( nodes ) :
 918                 listofnodes = listofnodes + ',' + nodes[ i ].Name()
 919                 i = i + 1
 920         print listofnodes
 921         if len( args ) == 0 :
 922             aName = self.N.Name()
 923         else :
 924             aName = args[ 0 ]
 925         if len( nodes ) == 1 :
 926             listofnodes = "[" + listofnodes + "] = " + aName + ".Nodes()"
 927         else :
 928             listofnodes = listofnodes + " = " + aName + ".Nodes()"
 929         return listofnodes
 930     def PrintNodes( self ):
 931         nodes = self.Nodes()
 932         n = len( nodes )
 933         i = 0
 934         while i < n :
 935             print ' '
 936             nodes[ i ].Print()
 937             i = i + 1
 938     def PrintThreads( self ):
 939         nodes = self.Nodes()
 940         i = 0
 941         while i < len( nodes ) :
 942             print nodes[i].Name(),nodes[i].Thread(),nodes[i].State(),nodes[i].Control(),nodes[i].AutoState()
 943             i = i + 1
 944     def GLinks( self ):
 945         links = self.G.GLinks()
 946         i = 0
 947         while i < len( links ) :
 948             links[ i ] = Link( links[i] , self.G.Verbose )
 949             i = i + 1
 950         return links
 951     def ListLinks( self , *args ):
 952         links = self.G.GLinks()
 953         if len( links ) :
 954             listoflinks = links[ 0 ].InPort().Node().Name()
 955             listoflinks = listoflinks + links[ 0 ].InPort().Name()
 956             i = 1
 957             while i < len( links ) :
 958                 listoflinks = listoflinks + ',' + links[ i ].InPort().Node().Name()
 959                 listoflinks = listoflinks + links[ i ].InPort().Name()
 960                 i = i + 1
 961         print listoflinks
 962         if len( args ) == 0 :
 963             aName = self.N.Name()
 964         else :
 965             aName = args[ 0 ]
 966         if len( links ) == 1 :
 967             listoflinks = "[" + listoflinks + "] = " + aName + ".GLinks()"
 968         else :
 969             listoflinks = listoflinks + " = " + aName + ".GLinks()"
 970         return listoflinks
 971     def PrintLinks( self ):
 972         links = self.G.GLinks()
 973         i = 0
 974         while i < len( links ) :
 975             Link( links[ i ] , self.G.Verbose ).Print()
 976             i = i + 1
 977     def Graphs( self ):
 978         graphs = self.G.Graphs()
 979         outgraphs = graphs
 980         i = 0
 981         while i < len( graphs ) :
 982             outgraphs[ i ] = Graph( graphs[i].Name() , self.G.Verbose )
 983             outgraphs[ i ].Merge( graphs[i] )
 984             i = i + 1
 985         return outgraphs
 986     def Copy( self ):
 987         aCopy = self.G.Copy()
 988         if aCopy != None:
 989             myCopy = Graph( aCopy )
 990             return myCopy
 991         ErrMsg = "Failed to get a Copy of " + self.G.Name()
 992         if self.G.Verbose :
 993             print ErrMsg
 994         return aCopy
 995     def Merge( self , aGraph ):
 996         return self.G.Merge( aGraph.G )
 997     def Destroy( self ):
 998         self.N.destroy()
 999
1000 ##########################################################
1001 class GraphE(Graph):
1002 ##########################################################
1003     def __init__( self , aName ):
1004         graph = SuperVision.GraphE( aName )
1005         self.G = graph
1006         self.G.Verbose = 1
1007         self.N = graph
1008         self.N.Verbose = 1
1009
1010 ##########################################################
1011 class Value:
1012 ##########################################################
1013     def __init__( self , aValue , Verbose ):
1014         self.V = aValue
1015         self.V.Verbose = Verbose
1016     def ToString( self ):
1017         return self.V.ToString()
1018     def ToAny( self ):
1019         return self.V.ToAny()
1020     def Destroy( self ):
1021         self.N.destroy()
1022
1023 ##########################################################
1024 class Port:
1025 ##########################################################
1026     def __init__( self , aPort , Verbose ):
1027         self.P = aPort
1028         self.P.Verbose = Verbose
1029     def Input( self , *args ):
1030         types, realargs = getRealArgs(self.P,args)
1031         fn = bs_AddInput_valuedict[types]
1032         anInput = apply( fn, realargs)
1033         return anInput
1034     def Node( self ):
1035         aNode = self.P.Node()
1036         if aNode != None :
1037             if aNode.IsComputing() :
1038                 myNode = CNode( aNode , self.P.Verbose )
1039             elif aNode.IsFactory() :
1040                 myNode = FNode( aNode , self.P.Verbose )
1041             elif aNode.IsInLine() :
1042                 myNode = INode( aNode , self.P.Verbose )
1043             elif aNode.IsGOTO() :
1044                 myNode = GNode( aNode , self.P.Verbose )
1045             elif aNode.IsLoop() :
1046                 myNode = LNode( aNode , self.P.Verbose )
1047             elif aNode.IsEndLoop() :
1048                 myNode = ELNode( aNode , self.P.Verbose )
1049             elif aNode.IsSwitch() :
1050                 myNode = SNode( aNode , self.P.Verbose )
1051             elif aNode.IsEndSwitch() :
1052                 myNode = ESNode( aNode , self.P.Verbose )
1053             else :
1054                 myNode = None
1055             return myNode
1056         return aNode
1057     def Name( self ):
1058         return self.P.Name()
1059     def Type( self ):
1060         return self.P.Type()
1061     def Link( self ):
1062         aLink = self.P.Link()
1063         if aLink != None :
1064             myLink = Link( aLink , self.P.Verbose )
1065             return myLink
1066         ErrMsg = "Failed to get a Link to " + self.P.Node().Name() + "(" + self.P.Name() + ")"
1067         if self.P.Verbose :
1068             print ErrMsg
1069         return aLink
1070     def Links( self ):
1071         links = self.P.Links()
1072         i = 0
1073         while i < len( links ) :
1074             links[ i ] = Link( links[i] , self.P.Verbose )
1075             i = i + 1
1076         return links
1077     def PrintLinks( self ):
1078         links = self.P.Links()
1079         i = 0
1080         while i < len( links ) :
1081             Link( links[ i ] , self.P.Verbose ).Print()
1082             i = i + 1
1083     def IsInput( self ):
1084         return self.P.IsInput()
1085     def IsLinked( self ):
1086         return self.P.IsLinked()
1087     def HasInput( self ):
1088         return self.P.HasInput()
1089     def Kind( self ) :
1090         return self.P.Kind()
1091     def IsParam( self ):
1092         return self.P.IsParam()
1093     def IsGate( self ):
1094         return self.P.IsGate()
1095     def IsLoop( self ):
1096         return self.P.IsLoop()
1097     def IsInLine( self ):
1098         return self.P.IsInLine()
1099     def IsSwitch( self ):
1100         return self.P.IsSwitch()
1101     def IsEndSwitch( self ):
1102         return self.P.IsEndSwitch()
1103 #    def IsBus( self ):
1104 #        return self.P.IsBus()
1105     def Done( self ):
1106         return self.P.Done()
1107     def State( self ):
1108         return self.P.State()
1109     def ToString( self ):
1110         return self.P.ToString()
1111     def ToAny( self ):
1112         return self.P.ToAny()
1113     def Print( self ):
1114         if self.P.IsInput() :
1115             if self.P.IsLinked() :
1116                 print "In",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString(),' from ',self.Link().OutPort().Print()
1117             else :
1118                 print "In",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString()
1119         else :
1120             print "Out",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString()
1121     def Destroy( self ):
1122         self.P.destroy()
1123
1124 ##########################################################
1125 class Link:
1126 ##########################################################
1127     def __init__( self , aLink , Verbose ):
1128         self.L = aLink
1129         self.L.Verbose = Verbose
1130     def OutPort( self ):
1131         aPort = self.L.OutPort()
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 InPort( self ):
1139         aPort = self.L.InPort()
1140         if aPort != None :
1141             myPort = Port( aPort , self.L.Verbose )
1142             return myPort
1143         if self.L.Verbose :
1144             print "Error while getting the Port : "
1145         return None
1146     def Print( self ):
1147         anOutPort = self.L.OutPort()
1148         anInPort = self.L.InPort()
1149         print anOutPort.Node().Name(),'(',anOutPort.Name(),' ',anOutPort.Kind(),') =',anOutPort.ToString(),' --> ',anInPort.Node().Name(),'(',anInPort.Name(),')',' ',anInPort.Kind()
1150     def CoordsSize( self ):
1151         return self.L.CoordsSize()
1152     def AddCoord( self , index , X , Y ):
1153         return self.L.AddCoord( index , X , Y )
1154     def ChangeCoord( self , index , X , Y ):
1155         return self.L.ChangeCoord( index , X , Y )
1156     def RemoveCoord( self , index ):
1157         return self.L.RemoveCoord( index )
1158     def Coords( self , index ):
1159         return self.L.Coords( index )
1160     def destroy( self ):
1161         self.L.destroy()
1162
1163