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