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