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