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