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