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