from batchmode_salome import naming_service
from batchmode_salome import CORBA
from batchmode_salome import myStudy
+ import SALOME_ModuleCatalog
+ import SUPERV
+ import SUPERV_idl
except :
import curses
from LifeCycleCORBA import *
from SALOME_NamingServicePy import *
import SUPERV
import SUPERV_idl
+ import SALOME_ModuleCatalog
from batchmode_salome import *
# try :
# from libSuperVision_Swig import SuperV_Swig
# except :
# SuperV_Swig = None
orb = CORBA.ORB_init([''], CORBA.ORB_ID)
- lcc = LifeCycleCORBA(orb)
+ #lcc = LifeCycleCORBA(orb)
+ while lcc._catalog == None:
+ lcc = LifeCycleCORBA(orb)
naming_service = SALOME_NamingServicePy_i(orb)
+import os
import re
from types import *
+import readline
import SALOMEDS
import SALOMEDS_Attributes_idl
#try :
# print 'Supervision Component loaded'
SuperVision = lcc.FindOrLoadComponent("SuperVisionContainer","SUPERV")
-SuperVision.Swig = 0
+#SuperVision.Swig = 0
-modulecatalog = naming_service.Resolve("/Kernel/ModulCatalog")
+modulecatalog = None
+while modulecatalog == None:
+ modulecatalog = naming_service.Resolve("/Kernel/ModulCatalog")
myBuilder = myStudy.NewBuilder()
father = myStudy.FindComponent("SUPERV")
if self.N.IsFactory() :
print "ComponentName ",self.N.GetComponentName()
print "InterfaceName ",self.N.GetInterfaceName()
+ if self.N.IsStreamGraph() :
+ Timeout,DataStreamTrace,DeltaTime = self.G.StreamParams()
+ print "Timeout",Timeout
+ print "DataStreamTrace",DataStreamTrace
+ print "DeltaTime",DeltaTime
aService = self.N.Service()
print "Service Name ",aService.ServiceName
lenin = len( aService.ServiceinParameter )
# inp = Port( inp , self.N.Verbose )
# outp = Port( outp , self.N.Verbose )
# return sts,inp,outp
+ def InStreamPort( self , aParameterName , aParameterType , aDependency ):
+ aPort = self.N.InStreamPort( aParameterName , aParameterType , aDependency )
+ if aPort != None :
+ myPort = StreamPort( aPort , self.N.Verbose )
+ return myPort
+ if self.N.Verbose :
+ print "Error while creating the Port : ",aParameterName
+ return None
+ def OutStreamPort( self , aParameterName , aParameterType , aDependency ):
+ aPort = self.N.OutStreamPort( aParameterName , aParameterType , aDependency )
+ if aPort != None :
+ myPort = StreamPort( aPort , self.N.Verbose )
+ return myPort
+ if self.N.Verbose :
+ print "Error while creating the Port : ",aParameterName
+ return None
+ def GetInPort( self , aParameterName ):
+ aPort = self.N.GetInPort( aParameterName )
+ if aPort != None :
+ myPort = Port( aPort , self.N.Verbose )
+ return myPort
+ if self.N.Verbose :
+ print "Error while creating the Port : ",aParameterName
+ return None
+ def GetOutPort( self , aParameterName ):
+ aPort = self.N.GetOutPort( aParameterName )
+ if aPort != None :
+ myPort = Port( aPort , self.N.Verbose )
+ return myPort
+ if self.N.Verbose :
+ print "Error while creating the Port : ",aParameterName
+ return None
+ def GetInStreamPort( self , aParameterName ):
+ aPort = self.N.GetInStreamPort( aParameterName )
+ if aPort != None :
+ myPort = StreamPort( aPort , self.N.Verbose )
+ return myPort
+ if self.N.Verbose :
+ print "Error while creating the Port : ",aParameterName
+ return None
+ def GetOutStreamPort( self , aParameterName ):
+ aPort = self.N.GetOutStreamPort( aParameterName )
+ if aPort != None :
+ myPort = StreamPort( aPort , self.N.Verbose )
+ return myPort
+ if self.N.Verbose :
+ print "Error while creating the Port : ",aParameterName
+ return None
def Ports( self ):
ports = self.N.Ports()
i = 0
ports[ i ] = Port( ports[i] , self.N.Verbose )
i = i + 1
return ports
+ def StreamPorts( self ):
+ ports = self.N.StreamPorts()
+ i = 0
+ while i < len( ports ) :
+ ports[ i ] = StreamPort( ports[i] , self.N.Verbose )
+ i = i + 1
+ return ports
+ def AllPorts( self ):
+ allports = self.N.Ports()
+ lenports = len( allports )
+ i = 0
+ while i < lenports :
+ allports[ i ] = Port( allports[i] , self.N.Verbose )
+ i = i + 1
+ ports = self.N.StreamPorts()
+ i = 0
+ while i < len( ports ) :
+ allports.append( StreamPort( ports[i] , self.N.Verbose ) )
+ i = i + 1
+ return allports
def ListPorts( self , *args ):
if len( args ) == 0 :
aName = self.N.Name()
else :
aName = args[ 0 ]
- ports = self.N.Ports()
+ ports = self.AllPorts()
listofports = ""
+ ilst = 0
if len( ports ) :
portsname = ports[ 0 ].Name()
bs = portsname.find('\\')
portsname1,portsname2 = portsname.split('\\')
portsname = portsname1 + portsname2
if ports[ 0 ].IsInput():
- listofports = aName + 'In' + portsname
+ listofports = 'I' + aName + portsname
else :
- listofports = aName + 'Out' + portsname
+ listofports = 'O' + aName + portsname
i = 1
while i < len( ports ) :
portsname = ports[ i ].Name()
portsname1,portsname2 = portsname.split('\\')
portsname = portsname1 + portsname2
if ports[ i ].IsInput():
- listofports = listofports + ',' + aName + 'In' + portsname
+ listofports = listofports + ',' + 'I' + aName + portsname
else :
- listofports = listofports + ',' + aName + 'Out' + portsname
+ listofports = listofports + ',' + 'O' + aName + portsname
i = i + 1
print listofports
if len( ports ) == 1 :
- listofports = "[" + listofports + "] = " + aName + ".Ports()"
+ listofports = "[" + listofports + "] = " + aName + ".AllPorts()"
else :
- listofports = listofports + " = " + aName + ".Ports()"
+ listofports = listofports + " = " + aName + ".AllPorts()"
return listofports
def PrintPorts( self ):
- ports = self.N.Ports()
+ ports = self.AllPorts()
i = 0
while i < len( ports ) :
Direction = "Out"
if ports[ i ].IsInput() :
Direction = "In"
- print Direction,self.N.Name(),'(',ports[ i ].Name(),ports[ i ].Kind(),ports[ i ].Type(),') = ',ports[ i ].ToString()
+ if ( ports[ i ].IsDataStream() ) & ( self.N.IsStreamGraph() == 0 ) :
+ if ports[ i ].IsInput() :
+ sts,aKindOfSchema,aKindOfInterpolation,aKindOfExtrapolation = ports[ i ].Params()
+ print Direction,self.N.Name(),'(',ports[ i ].Name(),ports[ i ].Kind(),ports[ i ].Type(),') = ',ports[ i ].ToString(),ports[ i ].Dependency(),aKindOfSchema,aKindOfInterpolation,aKindOfExtrapolation
+ else :
+ numberofvalues = ports[ i ].NumberOfValues()
+ print Direction,self.N.Name(),'(',ports[ i ].Name(),ports[ i ].Kind(),ports[ i ].Type(),') = ',ports[ i ].ToString(),ports[ i ].Dependency(),'NumberOfValues',numberofvalues
+ else :
+ print Direction,self.N.Name(),'(',ports[ i ].Name(),ports[ i ].Kind(),ports[ i ].Type(),') = ',ports[ i ].ToString()
i = i + 1
def Links( self ) :
links = self.N.Links()
links[ i ] = Link( links[i] , self.N.Verbose )
i = i + 1
return links
+ def StreamLinks( self ) :
+ links = self.N.StreamLinks()
+ i = 0
+ while i < len( links ) :
+ links[ i ] = StreamLink( links[i] , self.N.Verbose )
+ i = i + 1
+ return links
+ def AllLinks( self ) :
+ alllinks = self.N.Links()
+ lenlinks = len( alllinks )
+ i = 0
+ while i < lenlinks :
+ alllinks[ i ] = Link( alllinks[i] , self.N.Verbose )
+ i = i + 1
+ links = self.N.StreamLinks()
+ i = 0
+ while i < len( links ) :
+ alllinks.append( StreamLink( links[i] , self.N.Verbose ) )
+ i = i + 1
+ return alllinks
+ def ListLinks( self , *args ):
+ links = self.AllLinks()
+ if len( links ) :
+ listoflinks = 'L' + links[ 0 ].OutPort().Node().Name()
+ listoflinks = listoflinks + links[ 0 ].OutPort().Name()
+ listoflinks = listoflinks + links[ 0 ].InPort().Node().Name()
+ listoflinks = listoflinks + links[ 0 ].InPort().Name()
+ i = 1
+ while i < len( links ) :
+ listoflinks = listoflinks + ',' + 'L' + links[ i ].OutPort().Node().Name()
+ listoflinks = listoflinks + links[ i ].OutPort().Name()
+ listoflinks = listoflinks + links[ i ].InPort().Node().Name()
+ listoflinks = listoflinks + links[ i ].InPort().Name()
+ i = i + 1
+ print listoflinks
+ if len( args ) == 0 :
+ aName = self.N.Name()
+ else :
+ aName = args[ 0 ]
+ if len( links ) == 1 :
+ listoflinks = "[" + listoflinks + "] = " + aName + ".AllLinks()"
+ else :
+ listoflinks = listoflinks + " = " + aName + ".AllLinks()"
+ return listoflinks
def PrintLinks( self ):
- links = self.Links()
+ links = self.AllLinks()
i = 0
while i < len( links ) :
links[i].Print()
i = i + 1
+ def IsStreamGraph( self ):
+ return self.N.IsStreamGraph()
def IsGraph( self ):
return self.N.IsGraph()
+ def IsMacro( self ):
+ return self.N.IsMacro()
+ def IsFlowMacro( self ):
+ return self.N.IsFlowMacro()
+ def IsStreamMacro( self ):
+ return self.N.IsStreamMacro()
def IsComputing( self ):
return self.N.IsComputing()
def IsFactory( self ):
return self.N.IsSwitch()
def IsEndSwitch( self ):
return self.N.IsEndSwitch()
+ def GraphLevel( self ) :
+ return self.N.GraphLevel()
def SubGraph( self ):
return self.N.SubGraph()
+ def SubStreamGraph( self ):
+ return self.N.SubStreamGraph()
def Thread( self ):
return self.N.Thread()
def IsWaiting( self ):
return self.N.Control()
def ControlClear( self ):
return self.N.ControlClear()
- def AutoState( self ):
- return self.N.AutoState()
def ReadyW( self ):
return self.N.ReadyW()
def RunningW( self ):
return self.N.DoneW()
def SuspendedW( self ):
return self.N.SuspendedW()
- def ReRun( self ):
- return self.N.ReRun()
- def ReStart( self ):
- return self.N.ReStart()
- def ReRunAt( self , aNodeName ):
- return self.N.ReRunAt( aNodeName )
- def ReStartAt( self , aNodeName ):
- return self.N.ReStartAt( aNodeName )
+ #def ReRun( self ):
+ # return self.N.ReRun()
+ #def ReStart( self ):
+ # return self.N.ReStart()
+ #def ReRunAt( self , aNodeName ):
+ # return self.N.ReRunAt( aNodeName )
+ #def ReStartAt( self , aNodeName ):
+ # return self.N.ReStartAt( aNodeName )
def Ping( self ):
return self.N.ping()
def Kill( self ):
return self.N.PyFunction()
def PyFuncName( self ):
return self.N.PyFuncName()
- def EPyFunc( self ):
- PyFunc = self.N.PyFunction()
- PyFunc = self.Edit( self.N.PyFuncName() , PyFunc )
- self.N.SetPyFunction( self.N.PyFuncName() , PyFunc )
def InPort( self , aParameterName , aParameterType ):
aPort = self.N.InPort( aParameterName ,
aParameterType )
if self.N.Verbose :
print "Error while creating the Port : ",aParameterName
return None
+ def EPyFunc( self ):
+ PyFunc = self.N.PyFunction()
+ PyFunc = self.Edit( self.N.PyFuncName() , PyFunc )
+ self.N.SetPyFunction( self.N.PyFuncName() , PyFunc )
##########################################################
class GNode(INode):
# self.Parametername = aServicesParameter.Parametername
##########################################################
-class Graph(INode):
+class Graph(GNode):
##########################################################
def __init__( self , aName ):
try:
try:
graph = aName.G.Copy()
except:
- graph = None
+ graph = aName
if graph != None :
+ if graph.IsStreamGraph() :
+ aGraph = graph.ToStreamGraph()
+ if aGraph != None :
+ graph = StreamGraph( aGraph )
+ else :
+ print "Graph creation failed"
self.G = graph
self.G.Verbose = 1
self.N = graph
print ErrMsg
return aNode
def Node( self , aComponent , anInterface , aService ):
- if SuperVision.Swig :
- aService = Service_Swig( aService )
+ #if SuperVision.Swig :
+ #aService = Service_Swig( aService )
return self.FNode( aComponent , anInterface , aService )
def FNode( self , aComponent , anInterface , aService ):
NodeComponent = modulecatalog.GetComponent( aComponent )
aService = NodeComponent.GetService( anInterface , aService )
- if SuperVision.Swig :
- aService = Service_Swig( aService )
+ #if SuperVision.Swig :
+ #aService = Service_Swig( aService )
aNode = self.G.FNode( aComponent , anInterface , aService )
if aNode != None :
myNode = FNode( aNode , self.G.Verbose )
# if self.G.Verbose :
# print ErrMsg
# return aNode
+ def MNode( self , aGraphXml ):
+ aMNode = self.G.MNode( aGraphXml )
+ if aMNode != None :
+ myMNode = MNode( aMNode , self.G.Verbose )
+ return myMNode
+ ErrMsg = "Failed to create a MNode"
+ if self.G.Verbose :
+ print ErrMsg
+ return aMNode
+ def GraphMNode( self , aGraph ):
+ aGraphMNode = self.G.GraphMNode( aGraph.G )
+ if aGraphMNode != None :
+ myMNode = MNode( aGraphMNode , self.G.Verbose )
+ return myMNode
+ ErrMsg = "Failed to create a MNode"
+ if self.G.Verbose :
+ print ErrMsg
+ return aGraphMNode
+ def FlowObjRef( self ) :
+ aGraph = self.G.FlowObjRef()
+ if aGraph != None :
+ myGraph = Graph( aGraph )
+ return myGraph
+ return aGraph
+ def StreamObjRef( self ) :
+ aGraph = self.G.StreamObjRef()
+ if aGraph != None :
+ myGraph = StreamGraph( aGraph )
+ return myGraph
+ return aGraph
def PrintService( self , aComponent , anInterface , aService ):
NodeComponent = modulecatalog.GetComponent( aComponent )
aService = NodeComponent.GetService( anInterface , aService )
return self.G.LevelMax()
def ThreadsMax( self ):
return self.G.ThreadsMax()
- def GraphsNumber( self ):
- return self.G.GraphsNumber()
+ def SubGraphsNumber( self ):
+ return self.G.SubGraphsNumber()
def LevelNodes( self , aLevel ):
nodes = self.G.LevelNodes( aLevel )
return self.nodesTuple( nodes )
pynodes.append( GNode( nodes.ESNodes[i] , self.G.Verbose ) )
i = i + 1
j = j + 1
+ n = len( nodes.Graphs )
+ i = 0
+ while i < n :
+ pynodes.append( MNode( nodes.Graphs[i] , self.G.Verbose ) )
+ i = i + 1
+ j = j + 1
return pynodes
def ListNodes( self , *args ):
nodes = self.Nodes()
i = 0
while i < n :
print ' '
- nodes[i].Print()
+ nodes[ i ].Print()
i = i + 1
def PrintThreads( self ):
nodes = self.Nodes()
i = 0
while i < len( nodes ) :
- print nodes[i].Name(),nodes[i].Thread(),nodes[i].State(),nodes[i].Control(),nodes[i].AutoState()
+ print nodes[i].Name(),nodes[i].Thread(),nodes[i].State(),nodes[i].Control(),nodes[i]
i = i + 1
def GLinks( self ):
links = self.G.GLinks()
i = 0
- while i < len( links ) :
+ linkslen = len( links )
+ #print 'GLinks ',linkslen,'Links'
+ while i < linkslen :
links[ i ] = Link( links[i] , self.G.Verbose )
i = i + 1
- return links
+ def GStreamLinks( self ):
+ streamlinks = self.G.GStreamLinks()
+ i = 0
+ #print 'GStreamLinks ',len( streamlinks ),'StreamLinks'
+ while i < len( streamlinks ) :
+ streamlinks[ i ] = StreamLink( streamlinks[i] , self.G.Verbose )
+ i = i + 1
+ return streamlinks
+ def GAllLinks( self ) :
+ alllinks = self.G.GLinks()
+ lenlinks = len( alllinks )
+ i = 0
+ while i < lenlinks :
+ alllinks[ i ] = Link( alllinks[i] , self.N.Verbose )
+ i = i + 1
+ links = self.G.StreamLinks()
+ j = 0
+ while j < len(links) :
+ alllinks.append( StreamLink( links[j] , self.N.Verbose ) )
+ i = i + 1
+ j = j + 1
+ return alllinks
def ListLinks( self , *args ):
- links = self.G.GLinks()
+ links = self.GAllLinks()
if len( links ) :
- listoflinks = links[ 0 ].InPort().Node().Name()
+ listoflinks = 'L' + links[ 0 ].OutPort().Node().Name()
+ listoflinks = listoflinks + links[ 0 ].OutPort().Name()
+ listoflinks = listoflinks + links[ 0 ].InPort().Node().Name()
listoflinks = listoflinks + links[ 0 ].InPort().Name()
i = 1
while i < len( links ) :
- listoflinks = listoflinks + ',' + links[ i ].InPort().Node().Name()
+ listoflinks = listoflinks + ',' + 'L' + links[ i ].OutPort().Node().Name()
+ listoflinks = listoflinks + links[ i ].OutPort().Name()
+ listoflinks = listoflinks + links[ i ].InPort().Node().Name()
listoflinks = listoflinks + links[ i ].InPort().Name()
i = i + 1
print listoflinks
else :
aName = args[ 0 ]
if len( links ) == 1 :
- listoflinks = "[" + listoflinks + "] = " + aName + ".GLinks()"
+ listoflinks = "[" + listoflinks + "] = " + aName + ".GAllLinks()"
else :
- listoflinks = listoflinks + " = " + aName + ".GLinks()"
+ listoflinks = listoflinks + " = " + aName + ".GAllLinks()"
return listoflinks
def PrintLinks( self ):
- links = self.G.GLinks()
+ links = self.GAllLinks()
i = 0
while i < len( links ) :
- Link( links[ i ] , self.G.Verbose ).Print()
+ links[ i ].Print()
i = i + 1
- def Graphs( self ):
- graphs = self.G.Graphs()
+ def SubGraphsNodes( self , ):
+ graphs = self.G.SubGraphsNodes()
outgraphs = graphs
i = 0
while i < len( graphs ) :
if self.G.Verbose :
print ErrMsg
return aCopy
+ def ToStreamGraph( self ):
+ aGraph = self.G.ToStreamGraph()
+ if aGraph != None :
+ return StreamGraph( aGraph )
+ return None
+ def SubGraphsNodes( self , aSubGraphsNumber ):
+ nodes = self.G.SubGraphsNodes( aSubGraphsNumber )
+ return self.nodesTuple( nodes )
def Merge( self , aGraph ):
return self.G.Merge( aGraph.G )
def Destroy( self ):
class GraphE(Graph):
##########################################################
def __init__( self , aName ):
- graph = SuperVision.GraphE( aName )
+ try:
+ graph = SuperVision.GraphE( aName )
+ except:
+ try:
+ graph = aName.G.Copy()
+ except:
+ graph = aName
+ if graph != None :
+ if graph.IsStreamGraph() :
+ aGraph = graph.ToStreamGraph()
+ if aGraph != None :
+ graph = StreamGraphE( aGraph )
+ else :
+ print "Graph creation failed"
+ self.G = graph
+ self.G.Verbose = 1
+ self.N = graph
+ self.N.Verbose = 1
+ else :
+ print "Graph creation failed"
+ def ToStreamGraph( self ):
+ aGraph = self.G.ToStreamGraph()
+ if aGraph != None :
+ return StreamGraphE( aGraph )
+ return None
+
+##########################################################
+class MNode(Graph):
+##########################################################
+ def __init__( self , aMNode , Verbose ):
+ self.G = aMNode
+ self.G.Verbose = Verbose
+ self.N = aMNode
+ self.N.Verbose = Verbose
+
+##########################################################
+class StreamGraph(Graph):
+##########################################################
+ def __init__( self , aName ):
+ try:
+ graph = SuperVision.StreamGraph( aName )
+ except:
+ try:
+ graph = aName.G.StreamCopy()
+ except:
+ graph = aName
+ if graph != None :
+ self.G = graph
+ self.G.Verbose = 1
+ self.N = graph
+ self.N.Verbose = 1
+ else :
+ print "StreamGraph creation failed"
+ def StreamCopy( self ):
+ aCopy = self.G.StreamCopy()
+ if aCopy != None:
+ myCopy = StreamGraph( aCopy )
+ return myCopy
+ ErrMsg = "Failed to get a Copy of " + self.G.Name()
+ if self.G.Verbose :
+ print ErrMsg
+ return aCopy
+ def StreamLink( self , anOutStreamPort , anInStreamPort ) :
+ aStreamLink = self.G.StreamLink( anOutStreamPort.P , anInStreamPort.P )
+ if aStreamLink!= None:
+ myStreamLink = StreamLink( aStreamLink , self.G.Verbose )
+ return myStreamLink
+ ErrMsg = "Failed to make a StreamLink in " + self.G.Name()
+ if self.G.Verbose :
+ print ErrMsg
+ return aStreamLink
+ def SetStreamParams( self , Timeout , DataStreamTrace , DeltaTime ):
+ return self.G.SetStreamParams( Timeout , DataStreamTrace , DeltaTime )
+ def StreamParams( self ):
+ Timeout,DataStreamTrace,DeltaTime = self.G.StreamParams()
+ return Timeout,DataStreamTrace,DeltaTime
+ def ToFlowGraph( self ):
+ return self.G.ToFlowGraph()
+ def SubStreamGraphsNumber( self ):
+ return self.G.SubStreamGraphsNumber()
+ def SubStreamGraphsNodes( self , aSubStreamGraphsNumber ):
+ nodes = self.G.SubStreamGraphsNodes( aSubStreamGraphsNumber )
+ return self.nodesTuple( nodes )
+ def StreamMerge( self , aStreamGraph ):
+ return self.G.StreamMerge( aStreamGraph.G )
+
+##########################################################
+class StreamGraphE(StreamGraph):
+##########################################################
+ def __init__( self , aName ):
+ graph = SuperVision.StreamGraphE( aName )
self.G = graph
self.G.Verbose = 1
self.N = graph
return self.P.IsSwitch()
def IsEndSwitch( self ):
return self.P.IsEndSwitch()
+ def IsDataStream( self ):
+ return self.P.IsDataStream()
# def IsBus( self ):
# return self.P.IsBus()
def Done( self ):
def Destroy( self ):
self.P.destroy()
+##########################################################
+class StreamPort(Port):
+##########################################################
+ def __init__( self , aPort , Verbose ):
+ self.P = aPort
+ self.P.Verbose = Verbose
+ def StreamLink( self ) :
+ return self.P.StreamLink()
+ def Dependency( self ) :
+ return self.P.Dependency()
+ def SetDependency( self , aDependency ) :
+ return self.P.SetDependency( aDependency )
+ def Params( self ) :
+ sts,aKindOfSchema,aKindOfInterpolation,aKindOfExtrapolation = self.P.Params()
+ return sts,aKindOfSchema,aKindOfInterpolation,aKindOfExtrapolation
+ def SetParams( self , aKindOfSchema , aKindOfInterpolation , aKindOfExtrapolation ) :
+ return self.P.SetParams( aKindOfSchema , aKindOfInterpolation , aKindOfExtrapolation )
+ def NumberOfValues( self ) :
+ return self.P.NumberOfValues()
+ def SetNumberOfValues( self , aNumberOfValues ) :
+ return self.P.SetNumberOfValues( aNumberOfValues )
+
##########################################################
class Link:
##########################################################
return None
def Print( self ):
anOutPort = self.L.OutPort()
+ anOutPortName = anOutPort.Name()
+ anOutPortKind = anOutPort.Kind()
+ anOutPortValue = anOutPort.ToString()
+ anOutNode = anOutPort.Node()
+ anOutNodeName = anOutNode.Name()
anInPort = self.L.InPort()
- print anOutPort.Node().Name(),'(',anOutPort.Name(),' ',anOutPort.Kind(),') =',anOutPort.ToString(),' --> ',anInPort.Node().Name(),'(',anInPort.Name(),')',' ',anInPort.Kind()
+ anInPortName = anInPort.Name()
+ anInPortKind = anInPort.Kind()
+ anInNode = anInPort.Node()
+ anInNodeName = anInNode.Name()
+ print anOutNodeName,'(',anOutPortName,' ',anOutPortKind,') =',anOutPortValue,' --> ',anInNodeName,'(',anInPortName,')',' ',anInPortKind
def CoordsSize( self ):
return self.L.CoordsSize()
def AddCoord( self , index , X , Y ):
return self.L.Coords( index )
def destroy( self ):
self.L.destroy()
+ def IsEqual( self, OtherLink ):
+ return self.L.IsEqual( OtherLink.L )
-
+##########################################################
+class StreamLink(Link):
+##########################################################
+ def __init__( self , aLink , Verbose ):
+ self.L = aLink
+ self.L.Verbose = Verbose
+ def OutStreamPort( self ):
+ aPort = self.L.OutStreamPort()
+ if aPort != None :
+ myPort = StreamPort( aPort , self.L.Verbose )
+ return myPort
+ if self.L.Verbose :
+ print "Error while getting the Port : "
+ return None
+ def InStreamPort( self ):
+ aPort = self.L.InStreamPort()
+ if aPort != None :
+ myPort = StreamPort( aPort , self.L.Verbose )
+ return myPort
+ if self.L.Verbose :
+ print "Error while getting the Port : "
+ return None
