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 IsReadOnly( self ) :
 873         return self.G.IsReadOnly()
 874     def ComponentRef( self , aFactoryServer , aComponent ) :
 875         return self.G.ComponentRef( aFactoryServer , aComponent )
 876     def IsValid( self ):
 877         return self.G.IsValid()
 878     def IsExecutable( self ):
 879         return self.G.IsExecutable()
 880     def IsEditing( self ):
 881         return self.G.IsEditing()
 882     def IsExecuting( self ):
 883         return self.G.IsExecuting()
 884     def LevelMax( self ):
 885         return self.G.LevelMax()
 886     def ThreadsMax( self ):
 887         return self.G.ThreadsMax()
 888     def SubGraphsNumber( self ):
 889         return self.G.SubGraphsNumber()
 890     def LevelNodes( self , aLevel ):
 891         nodes = self.G.LevelNodes( aLevel )
 892         return self.nodesTuple( nodes )
 893     def Run( self , *args ):
 894         self.S = -1
 895         aService = self.Service()
 896         nargs = len( args )
 897         i = 0
 898         while nargs > 0 :
 899             print aService.ServiceinParameter[ i ].Parametername," = ",args[i]
 900             self.Input( aService.ServiceinParameter[ i ].Parametername , args[i] )
 901             i = i + 1
 902             nargs = nargs - 1
 903         return self.G.Run()
 904     def Start( self , *args ):
 905         self.S = -1
 906         aService = self.Service()
 907         nargs = len( args )
 908         i = 0
 909         while nargs > 0 :
 910             print aService.ServiceinParameter[ i ].Parametername," = ",args[i]
 911             self.Input( aService.ServiceinParameter[ i ].Parametername , args[i] )
 912             i = i + 1
 913             nargs = nargs - 1
 914         return self.G.Start()
 915     def Event( self ):
 916         sts,aNode,anEvent,aState = self.G.Event()
 917         self.S = sts
 918         return sts,aNode,anEvent,aState
 919     def EventNoW( self ):
 920         sts,aNode,anEvent,aState = self.G.EventNoW()
 921         self.S = sts
 922         return sts,aNode,anEvent,aState
 923     def EventW( self ):
 924         sts,aNode,anEvent,aState = self.G.EventW()
 925         self.S = sts
 926         return sts,aNode,anEvent,aState
 927     def NextW( self ):
 928         if self.S != 0 :
 929             sts,aNode,anEvent,aState = self.G.EventW()
 930             self.S = sts
 931             print sts,aNode.Thread(),aNode.SubGraph(),aNode.Name(),anEvent,aState
 932         return sts
 933     def Threads( self ):
 934         return self.G.Threads()
 935     def SuspendedThreads( self ):
 936         return self.G.SuspendedThreads()
 937     def LastLevelDone( self ):
 938         return self.G.LastLevelDone()
 939     def Verbose( self , verbose ):
 940         preverbose = self.G.Verbose
 941         self.G.Verbose = verbose
 942         return preverbose
 943     def Nodes( self ):
 944         nodes = self.G.Nodes()
 945         return self.nodesTuple( nodes )
 946     def nodesTuple( self , nodes ) :
 947         n = len( nodes.CNodes )
 948         i = 0
 949         j = 0
 950         pynodes = []
 951         while i < n :
 952             pynodes.append( CNode( nodes.CNodes[i] , self.G.Verbose ) )
 953             i = i + 1
 954             j = j + 1
 955         n = len( nodes.FNodes )
 956         i = 0
 957         while i < n :
 958             pynodes.append( FNode( nodes.FNodes[i] , self.G.Verbose ) )
 959             i = i + 1
 960             j = j + 1
 961         n = len( nodes.INodes )
 962         i = 0
 963         while i < n :
 964             pynodes.append( INode( nodes.INodes[i] , self.G.Verbose ) )
 965             i = i + 1
 966             j = j + 1
 967         n = len( nodes.GNodes )
 968         i = 0
 969         while i < n :
 970             pynodes.append( GNode( nodes.GNodes[i] , self.G.Verbose ) )
 971             i = i + 1
 972             j = j + 1
 973         n = len( nodes.LNodes )
 974         i = 0
 975         while i < n :
 976             pynodes.append( LNode( nodes.LNodes[i] , self.G.Verbose ) )
 977             i = i + 1
 978             j = j + 1
 979         n = len( nodes.ELNodes )
 980         i = 0
 981         while i < n :
 982             pynodes.append( GNode( nodes.ELNodes[i] , self.G.Verbose ) )
 983             i = i + 1
 984             j = j + 1
 985         n = len( nodes.SNodes )
 986         i = 0
 987         while i < n :
 988             pynodes.append( SNode( nodes.SNodes[i] , self.G.Verbose ) )
 989             i = i + 1
 990             j = j + 1
 991         n = len( nodes.ESNodes )
 992         i = 0
 993         while i < n :
 994             pynodes.append( GNode( nodes.ESNodes[i] , self.G.Verbose ) )
 995             i = i + 1
 996             j = j + 1
 997         n = len( nodes.Graphs )
 998         i = 0
 999         while i < n :
1000             pynodes.append( MNode( nodes.Graphs[i] , self.G.Verbose ) )
1001             i = i + 1
1002             j = j + 1
1003         return pynodes
1004     def ListNodes( self , *args ):
1005         nodes = self.Nodes()
1006         listofnodes = ""
1007         if len( nodes ) :
1008             listofnodes = nodes[ 0 ].Name()
1009             i = 1
1010             while i < len( nodes ) :
1011                 listofnodes = listofnodes + ',' + nodes[ i ].Name()
1012                 i = i + 1
1013         print listofnodes
1014         if len( args ) == 0 :
1015             aName = self.N.Name()
1016         else :
1017             aName = args[ 0 ]
1018         if len( nodes ) == 1 :
1019             listofnodes = "[" + listofnodes + "] = " + aName + ".Nodes()"
1020         else :
1021             listofnodes = listofnodes + " = " + aName + ".Nodes()"
1022         return listofnodes
1023     def PrintNodes( self ):
1024         nodes = self.Nodes()
1025         n = len( nodes )
1026         i = 0
1027         while i < n :
1028             print ' '
1029             nodes[ i ].Print()
1030             i = i + 1
1031     def PrintThreads( self ):
1032         nodes = self.Nodes()
1033         i = 0
1034         while i < len( nodes ) :
1035             print nodes[i].Name(),nodes[i].Thread(),nodes[i].State(),nodes[i].Control(),nodes[i]
1036             i = i + 1
1037     def GLinks( self ):
1038         links = self.G.GLinks()
1039         i = 0
1040         linkslen = len( links )
1041         #print 'GLinks ',linkslen,'Links'
1042         while i < linkslen :
1043             links[ i ] = Link( links[i] , self.G.Verbose )
1044             i = i + 1
1045     def GStreamLinks( self ):
1046         streamlinks = self.G.GStreamLinks()
1047         i = 0
1048         #print 'GStreamLinks ',len( streamlinks ),'StreamLinks'
1049         while i < len( streamlinks ) :
1050             streamlinks[ i ] = StreamLink( streamlinks[i] , self.G.Verbose )
1051             i = i + 1
1052         return streamlinks
1053     def GAllLinks( self ) :
1054         alllinks = self.G.GLinks()
1055         lenlinks = len( alllinks )
1056         i = 0
1057         while i < lenlinks :
1058             alllinks[ i ] = Link( alllinks[i] , self.N.Verbose )
1059             i = i + 1
1060         links = self.G.StreamLinks()
1061         j = 0
1062         while j < len(links) :
1063             alllinks.append( StreamLink( links[j] , self.N.Verbose ) )
1064             i = i + 1
1065             j = j + 1
1066         return alllinks
1067     def ListLinks( self , *args ):
1068         links = self.GAllLinks()
1069         if len( links ) :
1070             listoflinks = 'L' + links[ 0 ].OutPort().Node().Name()
1071             listoflinks = listoflinks + links[ 0 ].OutPort().Name()
1072             listoflinks = listoflinks + links[ 0 ].InPort().Node().Name()
1073             listoflinks = listoflinks + links[ 0 ].InPort().Name()
1074             i = 1
1075             while i < len( links ) :
1076                 listoflinks = listoflinks + ',' + 'L' + links[ i ].OutPort().Node().Name()
1077                 listoflinks = listoflinks + links[ i ].OutPort().Name()
1078                 listoflinks = listoflinks + links[ i ].InPort().Node().Name()
1079                 listoflinks = listoflinks + links[ i ].InPort().Name()
1080                 i = i + 1
1081         print listoflinks
1082         if len( args ) == 0 :
1083             aName = self.N.Name()
1084         else :
1085             aName = args[ 0 ]
1086         if len( links ) == 1 :
1087             listoflinks = "[" + listoflinks + "] = " + aName + ".GAllLinks()"
1088         else :
1089             listoflinks = listoflinks + " = " + aName + ".GAllLinks()"
1090         return listoflinks
1091     def PrintLinks( self ):
1092         links = self.GAllLinks()
1093         i = 0
1094         while i < len( links ) :
1095             links[ i ].Print()
1096             i = i + 1
1097     def SubGraphsNodes( self , ):
1098         graphs = self.G.SubGraphsNodes()
1099         outgraphs = graphs
1100         i = 0
1101         while i < len( graphs ) :
1102             outgraphs[ i ] = Graph( graphs[i].Name() , self.G.Verbose )
1103             outgraphs[ i ].Merge( graphs[i] )
1104             i = i + 1
1105         return outgraphs
1106     def Copy( self ):
1107         aCopy = self.G.Copy()
1108         if aCopy != None:
1109             myCopy = Graph( aCopy )
1110             return myCopy
1111         ErrMsg = "Failed to get a Copy of " + self.G.Name()
1112         if self.G.Verbose :
1113             print ErrMsg
1114         return aCopy
1115     def ToStreamGraph( self ):
1116         aGraph = self.G.ToStreamGraph()
1117         if aGraph != None :
1118             return StreamGraph( aGraph )
1119         return None
1120     def SubGraphsNodes( self , aSubGraphsNumber ):
1121         nodes = self.G.SubGraphsNodes( aSubGraphsNumber )
1122         return self.nodesTuple( nodes )
1123     def Merge( self , aGraph ):
1124         return self.G.Merge( aGraph.G )
1125     def Destroy( self ):
1126         self.N.destroy()
1127
1128 ##########################################################
1129 class GraphE(Graph):
1130 ##########################################################
1131     def __init__( self , aName ):
1132         graph = SuperVision.GraphE( aName )
1133         self.G = graph
1134         self.G.Verbose = 1
1135         self.N = graph
1136         self.N.Verbose = 1
1137     def ToStreamGraph( self ):
1138         aGraph = self.G.ToStreamGraph()
1139         if aGraph != None :
1140             return StreamGraphE( aGraph )
1141         return None
1142
1143 ##########################################################
1144 class MNode(Graph):
1145 ##########################################################
1146     def __init__( self , aMNode , Verbose ):
1147         self.G = aMNode
1148         self.G.Verbose = Verbose
1149         self.N = aMNode
1150         self.N.Verbose = Verbose
1151
1152 ##########################################################
1153 class StreamGraph(Graph):
1154 ##########################################################
1155     def __init__( self , aName ):
1156         try:
1157             graph = SuperVision.StreamGraph( aName )
1158         except:
1159             try:
1160                 graph = aName.G.StreamCopy()
1161             except:
1162                 graph = aName
1163         if graph != None :
1164             self.G = graph
1165             self.G.Verbose = 1
1166             self.N = graph
1167             self.N.Verbose = 1
1168         else :
1169             print "StreamGraph creation failed"
1170     def StreamCopy( self ):
1171         aCopy = self.G.StreamCopy()
1172         if aCopy != None:
1173             myCopy = StreamGraph( aCopy )
1174             return myCopy
1175         ErrMsg = "Failed to get a Copy of " + self.G.Name()
1176         if self.G.Verbose :
1177             print ErrMsg
1178         return aCopy
1179     def StreamLink( self , anOutStreamPort , anInStreamPort ) :
1180         aStreamLink = self.G.StreamLink( anOutStreamPort.P , anInStreamPort.P )
1181         if aStreamLink!= None:
1182             myStreamLink = StreamLink( aStreamLink , self.G.Verbose )
1183             return myStreamLink
1184         ErrMsg = "Failed to make a StreamLink in " + self.G.Name()
1185         if self.G.Verbose :
1186             print ErrMsg
1187         return aStreamLink
1188     def SetStreamParams( self , Timeout , DataStreamTrace , DeltaTime ):
1189         return self.G.SetStreamParams( Timeout , DataStreamTrace , DeltaTime )
1190     def StreamParams( self ):
1191         Timeout,DataStreamTrace,DeltaTime = self.G.StreamParams()
1192         return Timeout,DataStreamTrace,DeltaTime
1193     def ToFlowGraph( self ):
1194         return self.G.ToFlowGraph()
1195     def SubStreamGraphsNumber( self ):
1196         return self.G.SubStreamGraphsNumber()
1197     def SubStreamGraphsNodes( self , aSubStreamGraphsNumber ):
1198         nodes = self.G.SubStreamGraphsNodes( aSubStreamGraphsNumber )
1199         return self.nodesTuple( nodes )
1200     def StreamMerge( self , aStreamGraph ):
1201         return self.G.StreamMerge( aStreamGraph.G )
1202
1203 ##########################################################
1204 class StreamGraphE(StreamGraph):
1205 ##########################################################
1206     def __init__( self , aName ):
1207         graph = SuperVision.StreamGraphE( aName )
1208         self.G = graph
1209         self.G.Verbose = 1
1210         self.N = graph
1211         self.N.Verbose = 1
1212
1213 ##########################################################
1214 class Value:
1215 ##########################################################
1216     def __init__( self , aValue , Verbose ):
1217         self.V = aValue
1218         self.V.Verbose = Verbose
1219     def ToString( self ):
1220         return self.V.ToString()
1221     def ToAny( self ):
1222         return self.V.ToAny()
1223     def Destroy( self ):
1224         self.N.destroy()
1225
1226 ##########################################################
1227 class Port:
1228 ##########################################################
1229     def __init__( self , aPort , Verbose ):
1230         self.P = aPort
1231         self.P.Verbose = Verbose
1232     def Input( self , *args ):
1233         types, realargs = getRealArgs(self.P,args)
1234         fn = bs_AddInput_valuedict[types]
1235         anInput = apply( fn, realargs)
1236         return anInput
1237     def Node( self ):
1238         aNode = self.P.Node()
1239         if aNode != None :
1240             if aNode.IsComputing() :
1241                 myNode = CNode( aNode , self.P.Verbose )
1242             elif aNode.IsFactory() :
1243                 myNode = FNode( aNode , self.P.Verbose )
1244             elif aNode.IsInLine() :
1245                 myNode = INode( aNode , self.P.Verbose )
1246             elif aNode.IsGOTO() :
1247                 myNode = GNode( aNode , self.P.Verbose )
1248             elif aNode.IsLoop() :
1249                 myNode = LNode( aNode , self.P.Verbose )
1250             elif aNode.IsEndLoop() :
1251                 myNode = ELNode( aNode , self.P.Verbose )
1252             elif aNode.IsSwitch() :
1253                 myNode = SNode( aNode , self.P.Verbose )
1254             elif aNode.IsEndSwitch() :
1255                 myNode = ESNode( aNode , self.P.Verbose )
1256             else :
1257                 myNode = None
1258             return myNode
1259         return aNode
1260     def Name( self ):
1261         return self.P.Name()
1262     def Type( self ):
1263         return self.P.Type()
1264     def Link( self ):
1265         aLink = self.P.Link()
1266         if aLink != None :
1267             myLink = Link( aLink , self.P.Verbose )
1268             return myLink
1269         ErrMsg = "Failed to get a Link to " + self.P.Node().Name() + "(" + self.P.Name() + ")"
1270         if self.P.Verbose :
1271             print ErrMsg
1272         return aLink
1273     def Links( self ):
1274         links = self.P.Links()
1275         i = 0
1276         while i < len( links ) :
1277             links[ i ] = Link( links[i] , self.P.Verbose )
1278             i = i + 1
1279         return links
1280     def PrintLinks( self ):
1281         links = self.P.Links()
1282         i = 0
1283         while i < len( links ) :
1284             Link( links[ i ] , self.P.Verbose ).Print()
1285             i = i + 1
1286     def IsInput( self ):
1287         return self.P.IsInput()
1288     def IsLinked( self ):
1289         return self.P.IsLinked()
1290     def HasInput( self ):
1291         return self.P.HasInput()
1292     def Kind( self ) :
1293         return self.P.Kind()
1294     def IsParam( self ):
1295         return self.P.IsParam()
1296     def IsGate( self ):
1297         return self.P.IsGate()
1298     def IsLoop( self ):
1299         return self.P.IsLoop()
1300     def IsInLine( self ):
1301         return self.P.IsInLine()
1302     def IsSwitch( self ):
1303         return self.P.IsSwitch()
1304     def IsEndSwitch( self ):
1305         return self.P.IsEndSwitch()
1306     def IsDataStream( self ):
1307         return self.P.IsDataStream()
1308 #    def IsBus( self ):
1309 #        return self.P.IsBus()
1310     def Done( self ):
1311         return self.P.Done()
1312     def State( self ):
1313         return self.P.State()
1314     def ToString( self ):
1315         return self.P.ToString()
1316     def ToAny( self ):
1317         return self.P.ToAny()
1318     def Print( self ):
1319         if self.P.IsInput() :
1320             if self.P.IsLinked() :
1321                 print "In",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString(),' from ',self.Link().OutPort().Print()
1322             else :
1323                 print "In",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString()
1324         else :
1325             print "Out",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString()
1326     def Destroy( self ):
1327         self.P.destroy()
1328
1329 ##########################################################
1330 class StreamPort(Port):
1331 ##########################################################
1332     def __init__( self , aPort , Verbose ):
1333         self.P = aPort
1334         self.P.Verbose = Verbose
1335     def StreamLink( self ) :
1336         return self.P.StreamLink()
1337     def Dependency( self ) :
1338         return self.P.Dependency()
1339     def SetDependency( self , aDependency ) :
1340         return self.P.SetDependency( aDependency )
1341     def Params( self ) :
1342         sts,aKindOfSchema,aKindOfInterpolation,aKindOfExtrapolation = self.P.Params()
1343         return sts,aKindOfSchema,aKindOfInterpolation,aKindOfExtrapolation
1344     def SetParams( self , aKindOfSchema , aKindOfInterpolation , aKindOfExtrapolation ) :
1345         return self.P.SetParams( aKindOfSchema , aKindOfInterpolation , aKindOfExtrapolation )
1346     def NumberOfValues( self ) :
1347         return self.P.NumberOfValues()
1348     def SetNumberOfValues( self , aNumberOfValues ) :
1349         return self.P.SetNumberOfValues( aNumberOfValues )
1350
1351 ##########################################################
1352 class Link:
1353 ##########################################################
1354     def __init__( self , aLink , Verbose ):
1355         self.L = aLink
1356         self.L.Verbose = Verbose
1357     def OutPort( self ):
1358         aPort = self.L.OutPort()
1359         if aPort != None :
1360             myPort = Port( aPort , self.L.Verbose )
1361             return myPort
1362         if self.L.Verbose :
1363             print "Error while getting the Port : "
1364         return None
1365     def InPort( self ):
1366         aPort = self.L.InPort()
1367         if aPort != None :
1368             myPort = Port( aPort , self.L.Verbose )
1369             return myPort
1370         if self.L.Verbose :
1371             print "Error while getting the Port : "
1372         return None
1373     def Print( self ):
1374         anOutPort = self.L.OutPort()
1375         anOutPortName = anOutPort.Name()
1376         anOutPortKind = anOutPort.Kind()
1377         anOutPortValue = anOutPort.ToString()
1378         anOutNode = anOutPort.Node()
1379         anOutNodeName = anOutNode.Name()
1380         anInPort = self.L.InPort()
1381         anInPortName = anInPort.Name()
1382         anInPortKind = anInPort.Kind()
1383         anInNode = anInPort.Node()
1384         anInNodeName = anInNode.Name()
1385         print anOutNodeName,'(',anOutPortName,' ',anOutPortKind,') =',anOutPortValue,' --> ',anInNodeName,'(',anInPortName,')',' ',anInPortKind
1386     def CoordsSize( self ):
1387         return self.L.CoordsSize()
1388     def AddCoord( self , index , X , Y ):
1389         return self.L.AddCoord( index , X , Y )
1390     def ChangeCoord( self , index , X , Y ):
1391         return self.L.ChangeCoord( index , X , Y )
1392     def RemoveCoord( self , index ):
1393         return self.L.RemoveCoord( index )
1394     def Coords( self , index ):
1395         return self.L.Coords( index )
1396     def destroy( self ):
1397         self.L.destroy()
1398
1399
1400
1401 ##########################################################
1402 class StreamLink(Link):
1403 ##########################################################
1404     def __init__( self , aLink , Verbose ):
1405         self.L = aLink
1406         self.L.Verbose = Verbose
1407     def OutStreamPort( self ):
1408         aPort = self.L.OutStreamPort()
1409         if aPort != None :
1410             myPort = StreamPort( aPort , self.L.Verbose )
1411             return myPort
1412         if self.L.Verbose :
1413             print "Error while getting the Port : "
1414         return None
1415     def InStreamPort( self ):
1416         aPort = self.L.InStreamPort()
1417         if aPort != None :
1418             myPort = StreamPort( aPort , self.L.Verbose )
1419             return myPort
1420         if self.L.Verbose :
1421             print "Error while getting the Port : "
1422         return None