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 Thread( self ):
 468         return self.N.Thread()
 469     def IsWaiting( self ):
 470         return self.N.IsWaiting()
 471     def IsRunning( self ):
 472         return self.N.IsRunning()
 473     def IsDone( self ):
 474         return self.N.IsDone()
 475     def IsSuspended( self ):
 476         return self.N.IsSuspended()
 477     def State( self ):
 478         return self.N.State()
 479     def Control( self ):
 480         return self.N.Control()
 481     def ControlClear( self ):
 482         return self.N.ControlClear()
 483     def AutoState( self ):
 484         return self.N.AutoState()
 485     def ReadyW( self ):
 486         return self.N.ReadyW()
 487     def RunningW( self ):
 488         return self.N.RunningW()
 489     def DoneW( self ):
 490         return self.N.DoneW()
 491     def SuspendedW( self ):
 492         return self.N.SuspendedW()
 493     def ReRun( self ):
 494         return self.N.ReRun()
 495     def ReStart( self ):
 496         return self.N.ReStart()
 497     def ReRunAt( self , aNodeName ):
 498         return self.N.ReRunAt( aNodeName )
 499     def ReStartAt( self , aNodeName ):
 500         return self.N.ReStartAt( aNodeName )
 501     def Ping( self ):
 502         return self.N.ping()
 503     def Kill( self ):
 504         return self.N.Kill()
 505     def KillDone( self ):
 506         return self.N.KillDone()
 507     def Suspend( self ):
 508         return self.N.Suspend()
 509     def SuspendDone( self ):
 510         return self.N.SuspendDone()
 511     def Resume( self ):
 512         return self.N.Resume()
 513     def Stop( self ):
 514         return self.N.Stop()
 515     def Coords( self , X , Y ):
 516         return self.N.Coords( X , Y )
 517     def X( self ):
 518         return self.N.X()
 519     def Y( self ):
 520         return self.N.Y()
 521     def destroy( self ):
 522         self.N.destroy()
 523     def CpuUsed( self ):
 524         return self.N.CpuUsed()
 525
 526 ##########################################################
 527 class FNode(CNode):
 528 ##########################################################
 529     def __init__( self , aNode , Verbose ):
 530         self.N = aNode
 531         self.N.Verbose = Verbose
 532     def GetComponentName( self ):
 533         return self.N.GetComponentName()
 534     def GetInterfaceName( self ):
 535         return self.N._get_interfaceName()
 536     def GetContainer( self ):
 537         return self.N.GetContainer()
 538     def SetComponentName( self , aComponentName ):
 539         return self.N.SetComponentName( aComponentName )
 540     def SetInterfaceName( self , anInterfaceName ):
 541         return self.N.SetInterfaceName( anInterfaceName )
 542     def SetContainer( self , aComputer ):
 543         return self.N.SetContainer( aComputer )
 544
 545 ##########################################################
 546 class INode(CNode):
 547 ##########################################################
 548     def __init__( self , aNode , Verbose ):
 549         self.N = aNode
 550         self.N.Verbose = Verbose
 551     def Edit( self , FuncName , PyFunc ) :
 552         import os
 553         import random
 554         suf = str(random.randrange(1,10000))
 555         file = '/tmp/' + FuncName + '_' + suf + '.py'
 556         try :
 557             #d = dir ()
 558             #print "dir()",d
 559             fd = os.open( file , os.O_CREAT | os.O_WRONLY | os.O_TRUNC )
 560             #d = dir (fd)
 561             #print "dir(fd)",d
 562             i = 0
 563             while ( i < len( PyFunc ) ) :
 564                 print i,'/',len( PyFunc ),PyFunc[ i ]
 565                 os.write( fd , PyFunc[ i ] + '\n' )
 566                 i = i + 1
 567             os.close( fd )
 568             edit = '${EDITOR} ' + file
 569             os.system( edit )
 570             fd = os.open( file , os.O_RDONLY )
 571             line = os.read( fd , 132 )
 572             res = ''
 573             while len( line ) :
 574                 res = res + line
 575                 line = os.read( fd , 132 )
 576             os.close( fd )
 577             PyFunc = res.splitlines()
 578             i = 0
 579             while i < len( PyFunc ) :
 580                 print PyFunc[i]
 581                 i = i + 1
 582         except :
 583             print "Open of",file,"failed."
 584         return PyFunc
 585     def SetPyFunction( self , FuncName , aPyFunction ):
 586         return self.N.SetPyFunction( FuncName , aPyFunction )
 587     def PyFunction( self ):
 588         return self.N.PyFunction()
 589     def PyFuncName( self ):
 590         return self.N.PyFuncName()
 591     def InPort( self , aParameterName , aParameterType ):
 592         aPort = self.N.InPort( aParameterName ,
 593                              aParameterType )
 594         if aPort != None :
 595             myPort = Port( aPort , self.N.Verbose )
 596             return myPort
 597         if self.N.Verbose :
 598             print "Error while creating the Port : ",aParameterName
 599         return None
 600     def OutPort( self , aParameterName , aParameterType ):
 601         aPort = self.N.OutPort( aParameterName ,
 602                                 aParameterType )
 603         if aPort != None :
 604             myPort = Port( aPort , self.N.Verbose )
 605             return myPort
 606         if self.N.Verbose :
 607             print "Error while creating the Port : ",aParameterName
 608         return None
 609     def EPyFunc( self ):
 610         PyFunc = self.N.PyFunction()
 611         PyFunc = self.Edit( self.N.PyFuncName() , PyFunc )
 612         self.N.SetPyFunction( self.N.PyFuncName() , PyFunc )
 613
 614 ##########################################################
 615 class GNode(INode):
 616 ##########################################################
 617     def __init__( self , aNode , Verbose ):
 618         self.N = aNode
 619         self.N.Verbose = Verbose
 620     def SetCoupled( self , anInLineNode ):
 621         if self.N.IsGOTO() :
 622             node = self.N.SetCoupled( anInLineNode )
 623         else :
 624             node = None
 625         return node
 626     def Coupled( self ):
 627         node = self.N.Coupled()
 628         if node != None :
 629             if node.IsInLine() :
 630                 node = INode( node , self.N.Verbose )
 631             elif node.IsLoop() :
 632                 node = LNode( node , self.N.Verbose )
 633             elif node.IsEndLoop() :
 634                 node = ELNode( node , self.N.Verbose )
 635             elif node.IsSwitch() :
 636                 node = SNode( node , self.N.Verbose )
 637             elif node.IsEndSwitch() :
 638                 node = ESNode( node , self.N.Verbose )
 639         return node
 640
 641 ##########################################################
 642 class LNode(GNode):
 643 ##########################################################
 644     def __init__( self , aNode , Verbose ):
 645         self.N = aNode
 646         self.N.Verbose = Verbose
 647     def SetPyInit( self , InitName , aPyFunction ):
 648         return self.N.SetPyInit( InitName , aPyFunction )
 649     def PyInit( self ):
 650         return self.N.PyInit()
 651     def PyInitName( self ) :
 652         return self.N.PyInitName()
 653     def EPyInit( self ):
 654         PyFunc = self.N.PyFunction()
 655         PyFunc = self.Edit( self.N.PyFuncName() , PyFunc )
 656         self.N.SetPyFunction( self.N.PyFuncName() , PyFunc )
 657     def SetPyMore( self , MoreName , aPyFunction ):
 658         return self.N.SetPyMore( MoreName , aPyFunction )
 659     def PyMore( self ):
 660         return self.N.PyMore()
 661     def PyMoreName( self ) :
 662         return self.N.PyMoreName()
 663     def EPyMore( self ):
 664         PyMore = self.N.PyMore()
 665         PyMore = self.Edit( self.N.PyMoreName() , PyMore )
 666         self.N.SetPyMore( self.N.PyMoreName() , PyMore )
 667     def SetPyNext( self , NextName , aPyFunction ):
 668         return self.N.SetPyNext( NextName , aPyFunction )
 669     def PyNext( self ):
 670         return self.N.PyNext()
 671     def PyNextName( self ) :
 672         return self.N.PyNextName()
 673     def EPyNext( self ):
 674         PyNext = self.N.PyNext()
 675         PyNext = self.Edit( self.N.PyNextName() , PyNext )
 676         self.N.SetPyNext( self.N.PyNextName() , PyNext )
 677
 678 ##########################################################
 679 class ELNode(GNode):
 680 ##########################################################
 681     def __init__( self , aNode , Verbose ):
 682         self.N = aNode
 683         self.N.Verbose = Verbose
 684
 685 ##########################################################
 686 class SNode(GNode):
 687 ##########################################################
 688     def __init__( self , aNode , Verbose ):
 689         self.N = aNode
 690         self.N.Verbose = Verbose
 691
 692 ##########################################################
 693 class ESNode(GNode):
 694 ##########################################################
 695     def __init__( self , aNode , Verbose ):
 696         self.N = aNode
 697         self.N.Verbose = Verbose
 698
 699 ##########################################################
 700 #class ServicesParameter_Swig :
 701 ##########################################################
 702 #    def __init__( self , aServicesParameter ):
 703 #        self.Parametertype = aServicesParameter.Parametertype
 704 #        self.Parametername = aServicesParameter.Parametername
 705
 706 ##########################################################
 707 class Graph(INode):
 708 ##########################################################
 709     def __init__( self , aName ):
 710         try:
 711             graph = SuperVision.Graph( aName )
 712         except:
 713             try:
 714                 graph = aName.G.Copy()
 715             except:
 716                 graph = None
 717         if graph != None :
 718             if graph.IsStreamGraph() :
 719                 aGraph = graph.ToStreamGraph()
 720                 if aGraph != None :
 721                     graph = StreamGraph( aGraph )
 722                 else :
 723                     print "Graph creation failed"
 724             self.G = graph
 725             self.G.Verbose = 1
 726             self.N = graph
 727             self.N.Verbose = 1
 728         else :
 729             print "Graph creation failed"
 730     def CNode( self , *args ):
 731         if len( args ) == 1 :
 732             aService = args[ 0 ]
 733         else :
 734             aComponent = args[ 0 ]
 735             anInterface = args[ 1 ]
 736             aService = args[ 2 ]
 737             NodeComponent = modulecatalog.GetComponent( aComponent )
 738             aService = NodeComponent.GetService( anInterface , aService )
 739         aNode = self.G.CNode( aService )
 740         if aNode != None :
 741             myNode = CNode( aNode , self.G.Verbose )
 742             return myNode
 743         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 744         if self.G.Verbose :
 745             print ErrMsg
 746         return aNode
 747     def Node( self , aComponent , anInterface , aService ):
 748         #if SuperVision.Swig :
 749             #aService = Service_Swig( aService )
 750         return self.FNode( aComponent , anInterface , aService )
 751     def FNode( self , aComponent , anInterface , aService ):
 752         NodeComponent = modulecatalog.GetComponent( aComponent )
 753         aService = NodeComponent.GetService( anInterface , aService )
 754         #if SuperVision.Swig :
 755             #aService = Service_Swig( aService )
 756         aNode = self.G.FNode( aComponent , anInterface , aService )
 757         if aNode != None :
 758             myNode = FNode( aNode , self.G.Verbose )
 759             return myNode
 760         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 761         if self.G.Verbose :
 762             print ErrMsg
 763         return aNode
 764     def INode( self , FuncName , aPythonFunction ):
 765         aNode = self.G.INode( FuncName , aPythonFunction )
 766         if aNode != None :
 767             myNode = INode( aNode , self.G.Verbose )
 768             return myNode
 769         ErrMsg = "Failed to create a Node"
 770         if self.G.Verbose :
 771             print ErrMsg
 772             return aNode
 773     def GNode( self , FuncName , aPythonFunction , anINode ):
 774         aNode = self.G.GNode( FuncName , aPythonFunction , anINode )
 775         if aNode != None :
 776             myNode = GNode( aNode , self.G.Verbose )
 777             return myNode
 778         ErrMsg = "Failed to create a Node"
 779         if self.G.Verbose :
 780             print ErrMsg
 781             return aNode
 782     def LNode( self , InitName , InitFunction , MoreName , MoreFunction , NextName , NextFunction ):
 783         aNode,anEndOfLoop = self.G.LNode( InitName , InitFunction , MoreName , MoreFunction , NextName , NextFunction )
 784         if aNode != None :
 785             myNode = LNode( aNode , self.G.Verbose )
 786             myEndOfLoop = INode( anEndOfLoop , self.G.Verbose )
 787             return myNode,myEndOfLoop
 788         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 789         if self.G.Verbose :
 790             print ErrMsg
 791         return aNode
 792     def SNode( self , FuncName , aPythonFunction ):
 793         aNode,anEndOfSwitch = self.G.SNode( FuncName , aPythonFunction )
 794         if aNode != None :
 795             myNode = SNode( aNode , self.G.Verbose )
 796             myEndOfSwitch = INode( anEndOfSwitch , self.G.Verbose )
 797             return myNode,myEndOfSwitch
 798         ErrMsg = "Failed to create a Node"
 799         if self.G.Verbose :
 800             print ErrMsg
 801         return aNode
 802     def PrintService( self , aComponent , anInterface , aService ):
 803         NodeComponent = modulecatalog.GetComponent( aComponent )
 804         aService = NodeComponent.GetService( anInterface , aService )
 805         print "ServiceName ",aService.ServiceName," :"
 806         lenin = len( aService.ServiceinParameter )
 807         print "   ",lenin," input argument(s) :"
 808         i = 0
 809         while i < lenin :
 810             print "      ",i,". ",aService.ServiceinParameter[ i ].Parametername," ",aService.ServiceinParameter[ i ].Parametertype
 811             i = i + 1
 812         lenout = len( aService.ServiceoutParameter )
 813         print "   ",lenout," output argument(s) :"
 814         i = 0
 815         while i < lenout :
 816             print "      ",i,". ",aService.ServiceoutParameter[ i ].Parametername," ",aService.ServiceoutParameter[ i ].Parametertype
 817             i = i + 1
 818     def Link( self , aFromNodePort , aToNodePort ):
 819         aLink = self.G.Link( aFromNodePort.P , aToNodePort.P )
 820         if aLink != None :
 821             myLink = Link( aLink , self.G.Verbose )
 822             return myLink
 823         ErrMsg = "Failed to create a Link from " + aFromNodePort.Node().Name() + "(" + aFromNodePort.Name() + ") to " + aToNodePort.Node().Name() + "(" + aToNodePort.Name() + ")"
 824         if self.G.Verbose :
 825             print ErrMsg
 826         return aLink
 827     def Import( self , anXmlFileName ):
 828         return self.G.Import( anXmlFileName )
 829     def Export( self , anXmlFileName ):
 830         return self.G.Export( anXmlFileName )
 831     def IsReadOnly( self ) :
 832         return self.G.IsReadOnly()
 833     def ComponentRef( self , aFactoryServer , aComponent ) :
 834         return self.G.ComponentRef( aFactoryServer , aComponent )
 835     def IsValid( self ):
 836         return self.G.IsValid()
 837     def IsExecutable( self ):
 838         return self.G.IsExecutable()
 839     def IsEditing( self ):
 840         return self.G.IsEditing()
 841     def IsExecuting( self ):
 842         return self.G.IsExecuting()
 843     def LevelMax( self ):
 844         return self.G.LevelMax()
 845     def ThreadsMax( self ):
 846         return self.G.ThreadsMax()
 847     def GraphsNumber( self ):
 848         return self.G.GraphsNumber()
 849     def LevelNodes( self , aLevel ):
 850         nodes = self.G.LevelNodes( aLevel )
 851         return self.nodesTuple( nodes )
 852     def Run( self , *args ):
 853         self.S = -1
 854         aService = self.Service()
 855         nargs = len( args )
 856         i = 0
 857         while nargs > 0 :
 858             print aService.ServiceinParameter[ i ].Parametername," = ",args[i]
 859             self.Input( aService.ServiceinParameter[ i ].Parametername , args[i] )
 860             i = i + 1
 861             nargs = nargs - 1
 862         return self.G.Run()
 863     def Start( self , *args ):
 864         self.S = -1
 865         aService = self.Service()
 866         nargs = len( args )
 867         i = 0
 868         while nargs > 0 :
 869             print aService.ServiceinParameter[ i ].Parametername," = ",args[i]
 870             self.Input( aService.ServiceinParameter[ i ].Parametername , args[i] )
 871             i = i + 1
 872             nargs = nargs - 1
 873         return self.G.Start()
 874     def Event( self ):
 875         sts,aNode,anEvent,aState = self.G.Event()
 876         self.S = sts
 877         return sts,aNode,anEvent,aState
 878     def EventNoW( self ):
 879         sts,aNode,anEvent,aState = self.G.EventNoW()
 880         self.S = sts
 881         return sts,aNode,anEvent,aState
 882     def EventW( self ):
 883         sts,aNode,anEvent,aState = self.G.EventW()
 884         self.S = sts
 885         return sts,aNode,anEvent,aState
 886     def NextW( self ):
 887         if self.S != 0 :
 888             sts,aNode,anEvent,aState = self.G.EventW()
 889             self.S = sts
 890             print sts,aNode.Thread(),aNode.SubGraph(),aNode.Name(),anEvent,aState
 891         return sts
 892     def Threads( self ):
 893         return self.G.Threads()
 894     def SuspendedThreads( self ):
 895         return self.G.SuspendedThreads()
 896     def LastLevelDone( self ):
 897         return self.G.LastLevelDone()
 898     def Verbose( self , verbose ):
 899         preverbose = self.G.Verbose
 900         self.G.Verbose = verbose
 901         return preverbose
 902     def Nodes( self ):
 903         nodes = self.G.Nodes()
 904         return self.nodesTuple( nodes )
 905     def nodesTuple( self , nodes ) :
 906         n = len( nodes.CNodes )
 907         i = 0
 908         j = 0
 909         pynodes = []
 910         while i < n :
 911             pynodes.append( CNode( nodes.CNodes[i] , self.G.Verbose ) )
 912             i = i + 1
 913             j = j + 1
 914         n = len( nodes.FNodes )
 915         i = 0
 916         while i < n :
 917             pynodes.append( FNode( nodes.FNodes[i] , self.G.Verbose ) )
 918             i = i + 1
 919             j = j + 1
 920         n = len( nodes.INodes )
 921         i = 0
 922         while i < n :
 923             pynodes.append( INode( nodes.INodes[i] , self.G.Verbose ) )
 924             i = i + 1
 925             j = j + 1
 926         n = len( nodes.GNodes )
 927         i = 0
 928         while i < n :
 929             pynodes.append( GNode( nodes.GNodes[i] , self.G.Verbose ) )
 930             i = i + 1
 931             j = j + 1
 932         n = len( nodes.LNodes )
 933         i = 0
 934         while i < n :
 935             pynodes.append( LNode( nodes.LNodes[i] , self.G.Verbose ) )
 936             i = i + 1
 937             j = j + 1
 938         n = len( nodes.ELNodes )
 939         i = 0
 940         while i < n :
 941             pynodes.append( GNode( nodes.ELNodes[i] , self.G.Verbose ) )
 942             i = i + 1
 943             j = j + 1
 944         n = len( nodes.SNodes )
 945         i = 0
 946         while i < n :
 947             pynodes.append( SNode( nodes.SNodes[i] , self.G.Verbose ) )
 948             i = i + 1
 949             j = j + 1
 950         n = len( nodes.ESNodes )
 951         i = 0
 952         while i < n :
 953             pynodes.append( GNode( nodes.ESNodes[i] , self.G.Verbose ) )
 954             i = i + 1
 955             j = j + 1
 956         return pynodes
 957     def ListNodes( self , *args ):
 958         nodes = self.Nodes()
 959         listofnodes = ""
 960         if len( nodes ) :
 961             listofnodes = nodes[ 0 ].Name()
 962             i = 1
 963             while i < len( nodes ) :
 964                 listofnodes = listofnodes + ',' + nodes[ i ].Name()
 965                 i = i + 1
 966         print listofnodes
 967         if len( args ) == 0 :
 968             aName = self.N.Name()
 969         else :
 970             aName = args[ 0 ]
 971         if len( nodes ) == 1 :
 972             listofnodes = "[" + listofnodes + "] = " + aName + ".Nodes()"
 973         else :
 974             listofnodes = listofnodes + " = " + aName + ".Nodes()"
 975         return listofnodes
 976     def PrintNodes( self ):
 977         nodes = self.Nodes()
 978         n = len( nodes )
 979         i = 0
 980         while i < n :
 981             print ' '
 982             nodes[ i ].Print()
 983             i = i + 1
 984     def PrintThreads( self ):
 985         nodes = self.Nodes()
 986         i = 0
 987         while i < len( nodes ) :
 988             print nodes[i].Name(),nodes[i].Thread(),nodes[i].State(),nodes[i].Control(),nodes[i].AutoState()
 989             i = i + 1
 990     def GLinks( self ):
 991         links = self.G.GLinks()
 992         i = 0
 993         linkslen = len( links )
 994         #print 'GLinks ',linkslen,'Links'
 995         while i < linkslen :
 996             links[ i ] = Link( links[i] , self.G.Verbose )
 997             i = i + 1
 998     def GStreamLinks( self ):
 999         streamlinks = self.G.GStreamLinks()
1000         i = 0
1001         #print 'GStreamLinks ',len( streamlinks ),'StreamLinks'
1002         while i < len( streamlinks ) :
1003             streamlinks[ i ] = StreamLink( streamlinks[i] , self.G.Verbose )
1004             i = i + 1
1005         return streamlinks
1006     def GAllLinks( self ) :
1007         alllinks = self.G.GLinks()
1008         lenlinks = len( alllinks )
1009         i = 0
1010         while i < lenlinks :
1011             alllinks[ i ] = Link( alllinks[i] , self.N.Verbose )
1012             i = i + 1
1013         links = self.G.StreamLinks()
1014         j = 0
1015         while j < len(links) :
1016             alllinks.append( StreamLink( links[j] , self.N.Verbose ) )
1017             i = i + 1
1018             j = j + 1
1019         return alllinks
1020     def ListLinks( self , *args ):
1021         links = self.GAllLinks()
1022         if len( links ) :
1023             listoflinks = 'L' + links[ 0 ].OutPort().Node().Name()
1024             listoflinks = listoflinks + links[ 0 ].OutPort().Name()
1025             listoflinks = listoflinks + links[ 0 ].InPort().Node().Name()
1026             listoflinks = listoflinks + links[ 0 ].InPort().Name()
1027             i = 1
1028             while i < len( links ) :
1029                 listoflinks = listoflinks + ',' + 'L' + links[ i ].OutPort().Node().Name()
1030                 listoflinks = listoflinks + links[ i ].OutPort().Name()
1031                 listoflinks = listoflinks + links[ i ].InPort().Node().Name()
1032                 listoflinks = listoflinks + links[ i ].InPort().Name()
1033                 i = i + 1
1034         print listoflinks
1035         if len( args ) == 0 :
1036             aName = self.N.Name()
1037         else :
1038             aName = args[ 0 ]
1039         if len( links ) == 1 :
1040             listoflinks = "[" + listoflinks + "] = " + aName + ".GAllLinks()"
1041         else :
1042             listoflinks = listoflinks + " = " + aName + ".GAllLinks()"
1043         return listoflinks
1044     def PrintLinks( self ):
1045         links = self.GAllLinks()
1046         i = 0
1047         while i < len( links ) :
1048             links[ i ].Print()
1049             i = i + 1
1050     def Graphs( self ):
1051         graphs = self.G.Graphs()
1052         outgraphs = graphs
1053         i = 0
1054         while i < len( graphs ) :
1055             outgraphs[ i ] = Graph( graphs[i].Name() , self.G.Verbose )
1056             outgraphs[ i ].Merge( graphs[i] )
1057             i = i + 1
1058         return outgraphs
1059     def Copy( self ):
1060         aCopy = self.G.Copy()
1061         if aCopy != None:
1062             myCopy = Graph( aCopy )
1063             return myCopy
1064         ErrMsg = "Failed to get a Copy of " + self.G.Name()
1065         if self.G.Verbose :
1066             print ErrMsg
1067         return aCopy
1068     def ToStreamGraph( self ):
1069         aGraph = self.G.ToStreamGraph()
1070         if aGraph != None :
1071             return StreamGraph( aGraph )
1072         return None
1073     def Merge( self , aGraph ):
1074         return self.G.Merge( aGraph.G )
1075     def Destroy( self ):
1076         self.N.destroy()
1077
1078 ##########################################################
1079 class GraphE(Graph):
1080 ##########################################################
1081     def __init__( self , aName ):
1082         graph = SuperVision.GraphE( aName )
1083         self.G = graph
1084         self.G.Verbose = 1
1085         self.N = graph
1086         self.N.Verbose = 1
1087     def ToStreamGraph( self ):
1088         aGraph = self.G.ToStreamGraph()
1089         if aGraph != None :
1090             return StreamGraphE( aGraph )
1091         return None
1092
1093 ##########################################################
1094 class StreamGraph(Graph):
1095 ##########################################################
1096     def __init__( self , aName ):
1097         try:
1098             graph = SuperVision.StreamGraph( aName )
1099         except:
1100             try:
1101                 graph = aName.G.StreamCopy()
1102             except:
1103                 graph = aName
1104         if graph != None :
1105             self.G = graph
1106             self.G.Verbose = 1
1107             self.N = graph
1108             self.N.Verbose = 1
1109         else :
1110             print "StreamGraph creation failed"
1111     def StreamCopy( self ):
1112         aCopy = self.G.StreamCopy()
1113         if aCopy != None:
1114             myCopy = StreamGraph( aCopy )
1115             return myCopy
1116         ErrMsg = "Failed to get a Copy of " + self.G.Name()
1117         if self.G.Verbose :
1118             print ErrMsg
1119         return aCopy
1120     def StreamLink( self , anOutStreamPort , anInStreamPort ) :
1121         aStreamLink = self.G.StreamLink( anOutStreamPort.P , anInStreamPort.P )
1122         if aStreamLink!= None:
1123             myStreamLink = StreamLink( aStreamLink , self.G.Verbose )
1124             return myStreamLink
1125         ErrMsg = "Failed to make a StreamLink in " + self.G.Name()
1126         if self.G.Verbose :
1127             print ErrMsg
1128         return aStreamLink
1129     def SetStreamParams( self , Timeout , DataStreamTrace , DeltaTime ):
1130         return self.G.SetStreamParams( Timeout , DataStreamTrace , DeltaTime )
1131     def StreamParams( self ):
1132         Timeout,DataStreamTrace,DeltaTime = self.G.StreamParams()
1133         return Timeout,DataStreamTrace,DeltaTime
1134     def ToFlowGraph( self ):
1135         return self.G.ToFlowGraph()
1136
1137 ##########################################################
1138 class StreamGraphE(StreamGraph):
1139 ##########################################################
1140     def __init__( self , aName ):
1141         graph = SuperVision.StreamGraphE( aName )
1142         self.G = graph
1143         self.G.Verbose = 1
1144         self.N = graph
1145         self.N.Verbose = 1
1146
1147 ##########################################################
1148 class Value:
1149 ##########################################################
1150     def __init__( self , aValue , Verbose ):
1151         self.V = aValue
1152         self.V.Verbose = Verbose
1153     def ToString( self ):
1154         return self.V.ToString()
1155     def ToAny( self ):
1156         return self.V.ToAny()
1157     def Destroy( self ):
1158         self.N.destroy()
1159
1160 ##########################################################
1161 class Port:
1162 ##########################################################
1163     def __init__( self , aPort , Verbose ):
1164         self.P = aPort
1165         self.P.Verbose = Verbose
1166     def Input( self , *args ):
1167         types, realargs = getRealArgs(self.P,args)
1168         fn = bs_AddInput_valuedict[types]
1169         anInput = apply( fn, realargs)
1170         return anInput
1171     def Node( self ):
1172         aNode = self.P.Node()
1173         if aNode != None :
1174             if aNode.IsComputing() :
1175                 myNode = CNode( aNode , self.P.Verbose )
1176             elif aNode.IsFactory() :
1177                 myNode = FNode( aNode , self.P.Verbose )
1178             elif aNode.IsInLine() :
1179                 myNode = INode( aNode , self.P.Verbose )
1180             elif aNode.IsGOTO() :
1181                 myNode = GNode( aNode , self.P.Verbose )
1182             elif aNode.IsLoop() :
1183                 myNode = LNode( aNode , self.P.Verbose )
1184             elif aNode.IsEndLoop() :
1185                 myNode = ELNode( aNode , self.P.Verbose )
1186             elif aNode.IsSwitch() :
1187                 myNode = SNode( aNode , self.P.Verbose )
1188             elif aNode.IsEndSwitch() :
1189                 myNode = ESNode( aNode , self.P.Verbose )
1190             else :
1191                 myNode = None
1192             return myNode
1193         return aNode
1194     def Name( self ):
1195         return self.P.Name()
1196     def Type( self ):
1197         return self.P.Type()
1198     def Link( self ):
1199         aLink = self.P.Link()
1200         if aLink != None :
1201             myLink = Link( aLink , self.P.Verbose )
1202             return myLink
1203         ErrMsg = "Failed to get a Link to " + self.P.Node().Name() + "(" + self.P.Name() + ")"
1204         if self.P.Verbose :
1205             print ErrMsg
1206         return aLink
1207     def Links( self ):
1208         links = self.P.Links()
1209         i = 0
1210         while i < len( links ) :
1211             links[ i ] = Link( links[i] , self.P.Verbose )
1212             i = i + 1
1213         return links
1214     def PrintLinks( self ):
1215         links = self.P.Links()
1216         i = 0
1217         while i < len( links ) :
1218             Link( links[ i ] , self.P.Verbose ).Print()
1219             i = i + 1
1220     def IsInput( self ):
1221         return self.P.IsInput()
1222     def IsLinked( self ):
1223         return self.P.IsLinked()
1224     def HasInput( self ):
1225         return self.P.HasInput()
1226     def Kind( self ) :
1227         return self.P.Kind()
1228     def IsParam( self ):
1229         return self.P.IsParam()
1230     def IsGate( self ):
1231         return self.P.IsGate()
1232     def IsLoop( self ):
1233         return self.P.IsLoop()
1234     def IsInLine( self ):
1235         return self.P.IsInLine()
1236     def IsSwitch( self ):
1237         return self.P.IsSwitch()
1238     def IsEndSwitch( self ):
1239         return self.P.IsEndSwitch()
1240     def IsDataStream( self ):
1241         return self.P.IsDataStream()
1242 #    def IsBus( self ):
1243 #        return self.P.IsBus()
1244     def Done( self ):
1245         return self.P.Done()
1246     def State( self ):
1247         return self.P.State()
1248     def ToString( self ):
1249         return self.P.ToString()
1250     def ToAny( self ):
1251         return self.P.ToAny()
1252     def Print( self ):
1253         if self.P.IsInput() :
1254             if self.P.IsLinked() :
1255                 print "In",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString(),' from ',self.Link().OutPort().Print()
1256             else :
1257                 print "In",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString()
1258         else :
1259             print "Out",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString()
1260     def Destroy( self ):
1261         self.P.destroy()
1262
1263 ##########################################################
1264 class StreamPort(Port):
1265 ##########################################################
1266     def __init__( self , aPort , Verbose ):
1267         self.P = aPort
1268         self.P.Verbose = Verbose
1269     def StreamLink( self ) :
1270         return self.P.StreamLink()
1271     def Dependency( self ) :
1272         return self.P.Dependency()
1273     def SetDependency( self , aDependency ) :
1274         return self.P.SetDependency( aDependency )
1275     def Params( self ) :
1276         sts,aKindOfSchema,aKindOfInterpolation,aKindOfExtrapolation = self.P.Params()
1277         return sts,aKindOfSchema,aKindOfInterpolation,aKindOfExtrapolation
1278     def SetParams( self , aKindOfSchema , aKindOfInterpolation , aKindOfExtrapolation ) :
1279         return self.P.SetParams( aKindOfSchema , aKindOfInterpolation , aKindOfExtrapolation )
1280     def NumberOfValues( self ) :
1281         return self.P.NumberOfValues()
1282     def SetNumberOfValues( self , aNumberOfValues ) :
1283         return self.P.SetNumberOfValues( aNumberOfValues )
1284
1285 ##########################################################
1286 class Link:
1287 ##########################################################
1288     def __init__( self , aLink , Verbose ):
1289         self.L = aLink
1290         self.L.Verbose = Verbose
1291     def OutPort( self ):
1292         aPort = self.L.OutPort()
1293         if aPort != None :
1294             myPort = Port( aPort , self.L.Verbose )
1295             return myPort
1296         if self.L.Verbose :
1297             print "Error while getting the Port : "
1298         return None
1299     def InPort( self ):
1300         aPort = self.L.InPort()
1301         if aPort != None :
1302             myPort = Port( aPort , self.L.Verbose )
1303             return myPort
1304         if self.L.Verbose :
1305             print "Error while getting the Port : "
1306         return None
1307     def Print( self ):
1308         anOutPort = self.L.OutPort()
1309         anOutPortName = anOutPort.Name()
1310         anOutPortKind = anOutPort.Kind()
1311         anOutPortValue = anOutPort.ToString()
1312         anOutNode = anOutPort.Node()
1313         anOutNodeName = anOutNode.Name()
1314         anInPort = self.L.InPort()
1315         anInPortName = anInPort.Name()
1316         anInPortKind = anInPort.Kind()
1317         anInNode = anInPort.Node()
1318         anInNodeName = anInNode.Name()
1319         print anOutNodeName,'(',anOutPortName,' ',anOutPortKind,') =',anOutPortValue,' --> ',anInNodeName,'(',anInPortName,')',' ',anInPortKind
1320     def CoordsSize( self ):
1321         return self.L.CoordsSize()
1322     def AddCoord( self , index , X , Y ):
1323         return self.L.AddCoord( index , X , Y )
1324     def ChangeCoord( self , index , X , Y ):
1325         return self.L.ChangeCoord( index , X , Y )
1326     def RemoveCoord( self , index ):
1327         return self.L.RemoveCoord( index )
1328     def Coords( self , index ):
1329         return self.L.Coords( index )
1330     def destroy( self ):
1331         self.L.destroy()
1332
1333
1334
1335 ##########################################################
1336 class StreamLink(Link):
1337 ##########################################################
1338     def __init__( self , aLink , Verbose ):
1339         self.L = aLink
1340         self.L.Verbose = Verbose
1341     def OutStreamPort( self ):
1342         aPort = self.L.OutStreamPort()
1343         if aPort != None :
1344             myPort = StreamPort( aPort , self.L.Verbose )
1345             return myPort
1346         if self.L.Verbose :
1347             print "Error while getting the Port : "
1348         return None
1349     def InStreamPort( self ):
1350         aPort = self.L.InStreamPort()
1351         if aPort != None :
1352             myPort = StreamPort( aPort , self.L.Verbose )
1353             return myPort
1354         if self.L.Verbose :
1355             print "Error while getting the Port : "
1356         return None