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