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