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