src/Supervision/batchmode_SuperV.py

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