src/Supervision/SuperV.py

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