diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnCompositeNode.cpp b/VistaCoreLibs/VistaDataFlowNet/VdfnCompositeNode.cpp index 670b77ad369357119fb165c160ddab121ed5582c..825faf8eb3c8555d061742ee26dbeaf3584d3e2b 100644 --- a/VistaCoreLibs/VistaDataFlowNet/VdfnCompositeNode.cpp +++ b/VistaCoreLibs/VistaDataFlowNet/VdfnCompositeNode.cpp @@ -101,6 +101,8 @@ bool VdfnCompositeNode::SetInPort(const std::string &sName, IVdfnPort *pPort) } std::string sMappedName = (*cit).second.m_strPortName; + // if we found cit in the inport map, m_pTargetNode is not NULL!, + // see CreatePorts(), so no need to test against NULL here. if((*cit).second.m_pTargetNode->SetInPort( sMappedName, pPort )) { // register as mine... diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.cpp b/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.cpp index e23309add93f4fdeb3d268e0f53e9bf17d7b5516..e52b0a3dd7a20d77a1e751fcb65368280db41a41 100644 --- a/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.cpp +++ b/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.cpp @@ -124,7 +124,7 @@ bool VdfnGraph::EvaluateGraph(double nTimeStamp) if( EvaluateSubGraph( m_vecTraversal, nTimeStamp ) == false ) return false; - //check if any node needs a reevaluation + // check if any node needs a reevaluation std::map<IVdfnReEvalNode*, NodeVec>::reverse_iterator ritReEvalNode; std::map<IVdfnReEvalNode*, NodeVec>::reverse_iterator rbegin = m_mpReEvalSubgraphs.rbegin(); std::map<IVdfnReEvalNode*, NodeVec>::reverse_iterator rend = m_mpReEvalSubgraphs.rend(); @@ -133,7 +133,7 @@ bool VdfnGraph::EvaluateGraph(double nTimeStamp) // Determines if another evaluation run is required for the nodes // NeedsEval will usually true in the first, normal evaluation run, // but also indicated if a ReEvalNode needs another run afterwards - // The tests and reevaluations are performed back-to-front in order + // The tests and re-evaluations are performed back-to-front in order // to ensure that a further-down ReEvalNode is fully evaluated before // a ReEvalNode further-up can trigger and change the input if( (*ritReEvalNode).first->NeedsEval() ) @@ -247,6 +247,7 @@ IVdfnNode *VdfnGraph::GetNodeByName(const std::string &strName) const } return NULL; } + // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // EDGE MANAGEMENT // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -273,14 +274,13 @@ bool VdfnGraph::GetIsConnectedFromTo( IVdfnNode *pFrom, IVdfnNode *pTo) const return false; } -bool VdfnGraph::UpdatePorts() +void VdfnGraph::PrepareAllPorts() { for(Nodes::iterator uit = m_liNodes.begin(); uit != m_liNodes.end(); ++uit ) { if((*uit)->PreparePorts() == false) (*uit)->SetIsEnabled(false); } - return true; } @@ -332,8 +332,11 @@ bool VdfnGraph::ReloadActionObjects() { // ok, we found a parent node // add an edge to the edge-list - Connect &edges = GetAdjacencyList( (*pit).second, pit->first ); - edges.second.push_back( std::pair<IVdfnNode*, IVdfnPort*>(*cit, pPort) ); // add edge from (in_p) -> (sink_p) + Connect &edges = GetOrCreateAdjacencyListForNode( + (*pit).second, pit->first ); + // add edge from (in_p) -> (sink_p) + edges.second.push_back( std::pair<IVdfnNode*, + ConPortInfo>(*cit, ConPortInfo( *sit, pPort) ) ); } } @@ -346,8 +349,8 @@ bool VdfnGraph::ReloadActionObjects() bool VdfnGraph::UpdateTraversalVector() { - UpdatePorts(); - UpdatePortLookupMap(); + PrepareAllPorts(); + UpdateOutportLookupMap(); UpdateEdgeMap(); m_vecTraversal.clear(); @@ -360,9 +363,6 @@ bool VdfnGraph::UpdateTraversalVector() t != liPrts.end(); ++t ) { const ConInfo &liChildren = (*t).second; - - // ConInfo &liChildren = (*cit).second.second; - // add node with children to topology graph for( ConInfo::const_iterator nit = liChildren.begin(); nit != liChildren.end(); ++nit) @@ -375,11 +375,12 @@ bool VdfnGraph::UpdateTraversalVector() std::list<VistaTopologyGraph<IVdfnNode*>::Node*> liNodes = topology.CalcTopology(); - for(std::list<VistaTopologyGraph<IVdfnNode*>::Node*>::const_iterator tcit = liNodes.begin(); + for(std::list<VistaTopologyGraph<IVdfnNode*>::Node*>::const_iterator + tcit = liNodes.begin(); tcit != liNodes.end(); ++tcit) { m_vecTraversal.push_back( (*tcit)->m_oElement ); - //check if node is a reevalnode. if so, create its subgraph + //check if node is a re-evalnode. if so, create its subgraph IVdfnReEvalNode* pReEvalNode = dynamic_cast<IVdfnReEvalNode*>( (*tcit)->m_oElement ); // If a node is a ReEvalNode, it may become necessary to evaluate it multiple times per // frame. While the full graph is evaluated on the first run, a reevaluation should @@ -396,9 +397,11 @@ bool VdfnGraph::UpdateTraversalVector() std::vector<IVdfnNode*>& vecSubgraph = m_mpReEvalSubgraphs[pReEvalNode]; vecSubgraph.resize( liSubgraph.size() ); - std::list<VistaTopologyGraph<IVdfnNode*>::Node*>::const_iterator citOrigNode = liSubgraph.begin(); + std::list<VistaTopologyGraph<IVdfnNode*>::Node*>::const_iterator + citOrigNode = liSubgraph.begin(); std::vector<IVdfnNode*>::iterator itCopyNode = vecSubgraph.begin(); - std::list<VistaTopologyGraph<IVdfnNode*>::Node*>::const_iterator end = liSubgraph.end(); + std::list<VistaTopologyGraph<IVdfnNode*>::Node*>::const_iterator + end = liSubgraph.end(); for( ; citOrigNode != end; ++citOrigNode, ++itCopyNode ) (*itCopyNode) = (*citOrigNode)->m_oElement; @@ -411,7 +414,8 @@ bool VdfnGraph::UpdateTraversalVector() vstr::warnp() << "[VdfnGraph--" << strUserTag << "]: PrepareEvaluationRun() on node [" - << (*tcit)->m_oElement->GetNameForNameable() << "] failed to initialize." << std::endl; + << (*tcit)->m_oElement->GetNameForNameable() + << "] failed to initialize." << std::endl; } } @@ -424,16 +428,19 @@ bool VdfnGraph::UpdateTraversalVector() for(Nodes::const_iterator ucit = begin; ucit != end; ++ucit ) { - if( !topology.GetNodeByValue( *ucit ) ) // not in topology graph, so it is not in the edge list + // not in topology graph, so it is not in the edge list + if( !topology.GetNodeByValue( *ucit ) ) { // while we are at it: call initialize on these nodes :) if( (*ucit)->PrepareEvaluationRun() == true ) - m_vecTraversal.push_back( *ucit ); // order is not important, could be anywhere in the list + // order is not important, could be anywhere in the list + m_vecTraversal.push_back( *ucit ); else { // omit broken nodes vstr::warnp() << "[VdfnGraph]: PrepareEvaluationRun() on node [" - << (*ucit)->GetNameForNameable() << "] failed to initialize." << std::endl; + << (*ucit)->GetNameForNameable() + << "] failed to initialize." << std::endl; } } @@ -441,7 +448,7 @@ bool VdfnGraph::UpdateTraversalVector() return true; } -bool VdfnGraph::UpdatePortLookupMap() +bool VdfnGraph::UpdateOutportLookupMap() { // clear old values m_mpPortLookup.clear(); @@ -487,15 +494,19 @@ bool VdfnGraph::UpdateEdgeMap() { // ok, we found a parent node // add an edge to the edge-list - Connect &edges = GetAdjacencyList( (*pit).second, pit->first ); - edges.second.push_back( std::pair<IVdfnNode*, IVdfnPort*>(*cit, pPort) ); // add edge from (in_p) -> (sink_p) + Connect &edges = GetOrCreateAdjacencyListForNode( + (*pit).second, pit->first ); + // add edge and note the name as well + edges.second.push_back( + std::pair<IVdfnNode*, ConPortInfo>(*cit, + ConPortInfo( *sit, pPort) ) ); } } } } - return false; + return true; } IVdfnNode *VdfnGraph::GetNodeForPort( IVdfnPort *pPort ) const @@ -507,7 +518,8 @@ IVdfnNode *VdfnGraph::GetNodeForPort( IVdfnPort *pPort ) const } -VdfnGraph::Connect &VdfnGraph::GetAdjacencyList( IVdfnNode *pNode, IVdfnPort *pPort ) +VdfnGraph::Connect & +VdfnGraph::GetOrCreateAdjacencyListForNode( IVdfnNode *pNode, IVdfnPort *pPort ) { // lookup node in edge map Edges::iterator it = m_mpEdges.find( pNode ); @@ -515,7 +527,8 @@ VdfnGraph::Connect &VdfnGraph::GetAdjacencyList( IVdfnNode *pNode, IVdfnPort *pP { // add a new entry - it = m_mpEdges.insert( Edges::value_type( pNode, std::list<Connect>()) ).first; + it = m_mpEdges.insert( + Edges::value_type( pNode, std::list<Connect>()) ).first; (*it).second.push_back(Connect( pPort, ConInfo() )); } else @@ -524,6 +537,9 @@ VdfnGraph::Connect &VdfnGraph::GetAdjacencyList( IVdfnNode *pNode, IVdfnPort *pP for(std::list<Connect>::iterator cit = (*it).second.begin(); cit != (*it).second.end(); ++cit ) { + // FIXME this is problematic, if a port is shared multiple times + // (as it only searches for the first match, it may skip at least + // one edge). if( (*cit).first == pPort ) { return (*cit); @@ -549,7 +565,8 @@ void VdfnGraph::GetExports( ExportList &liExports ) const void VdfnGraph::SetExports(const ExportList &liExports) { - for(ExportList::const_iterator cit = liExports.begin(); cit != liExports.end(); ++cit) + for(ExportList::const_iterator cit = liExports.begin(); + cit != liExports.end(); ++cit) { const VdfnGraph::ExportData &exp = *cit; IVdfnNode *pNode = GetNodeByName( exp.m_strNodeName ); @@ -579,7 +596,7 @@ void VdfnGraph::SetExports(const ExportList &liExports) } } } - else + else if( exp.m_nDirection == VdfnGraph::ExportData::OUTPORT ) { if( pNode->GetOutPort( exp.m_strPortName ) == NULL ) { @@ -588,6 +605,12 @@ void VdfnGraph::SetExports(const ExportList &liExports) << exp.m_strNodeName << std::endl; } } + else + { + vstr::errp() << "VdfnGraph::SetExports() -- port direction not" + << " set (UNDEFINED), skipping this node declaration."; + continue; // for-loop + } m_liExports.push_back( exp ); } } diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.h b/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.h index a37a90c4124c44784f68c471ed47d88cb687a6a6..24257b12fe5c3c780a18b0e91eb87d4164e50f65 100644 --- a/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.h +++ b/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.h @@ -52,26 +52,49 @@ class IVdfnPort; /*============================================================================*/ /** - * The graph class. Contains nodes and edges. - * It is really not meant to traverse this graph's structure by hand as a programmer. - * There is code to do that. But you can do so, if you wish. - * Consequently, the use of typedefs like Nodes, Edges, ConInfo and Connect - * are used for expert access only. + * @brief Graph container and traversal interface. + * + * The VdfnGraph implements the following responsibilities. + * - management of nodes and detection of edges + * - definition of a traversal structure and evaluation algorithm + * - access structures for composite nodes (using Exports) + * - retrieval of "input nodes", i.e., nodes with 0 inports + * + * A graph can be active, i.e., the node traversal actually evaluates node + * values, or inactive, i.e., traversal does not change node values. + * + * @note It is really not meant to traverse this graph's structure by hand + * as a programmer. Meaning: this is not a general purpose graph data + * structure. */ class VISTADFNAPI VdfnGraph : public IVistaSerializable { public: + /** + * @brief helper structure to access graph 'exports'. + * Usually required in conjunction with Composite Nodes, i.e., nodes + * that contain graphs themselves. + * Exports define virtual in- and output ports of a graph that are + * reflected on a Composite Node. + * + * @see SetExports() + * @see GetExports() + */ class ExportData { public: enum eDir { - UNDEFINED=-1, - INPORT=0, - OUTPORT + UNDEFINED=-1, /**< error tag, initial value */ + INPORT=0, /**< export direction marks an inport */ + OUTPORT /**< export direction marks an outport */ }; + /** + * @brief default c'tor. + * Initializes export direction to UNDEFINED and target node as NULL + */ ExportData() : m_nDirection(UNDEFINED), m_pTargetNode(NULL) @@ -79,26 +102,34 @@ public: } + + /** + * @brief connection defining c'tor. + * @param strNodeName export defining node name + * @param strPortName port name from node <strNodeName> to export + * @param strMapName name to use when exporting the port + * @param direction choice between inport or outport. using + * undefined is, well, undefined. + */ ExportData( const std::string &strNodeName, - const std::string &strPortName, - const std::string &strMapName, - eDir direction, - IVdfnNode *pTargetNode = NULL) + const std::string &strPortName, + const std::string &strMapName, + eDir direction) : m_strNodeName(strNodeName), m_strPortName(strPortName), m_strMapName(strMapName), m_nDirection(direction), - m_pTargetNode(pTargetNode) + m_pTargetNode(NULL) { } - std::string m_strNodeName; - std::string m_strPortName; - std::string m_strMapName; + std::string m_strNodeName; /**< name of the node to export */ + std::string m_strPortName; /**< name of the port to export */ + std::string m_strMapName; /**< export name, can be used to rename ports */ - eDir m_nDirection; - IVdfnNode *m_pTargetNode; + eDir m_nDirection; /**< port direction, INPORT or OUTPORT */ + IVdfnNode *m_pTargetNode; /**< cache pointer in case of INPORT port */ }; /** @@ -106,17 +137,23 @@ public: */ typedef std::list<IVdfnNode*> Nodes; + /** + * used to note to which port the connection was done and under + * what name. + */ + typedef std::pair<std::string, IVdfnPort*> ConPortInfo; + /** * is meant to reflect a target node and a corresponding port * where the edge in coming in. */ - typedef std::list<std::pair<IVdfnNode*, IVdfnPort*> > ConInfo; + typedef std::list< std::pair<IVdfnNode*, ConPortInfo> > ConInfo; /** * maps all the nodes that are connected by Connect.first to * the list of Connect.second. */ - typedef std::pair<IVdfnPort*, ConInfo > Connect; + typedef std::pair<IVdfnPort*, ConInfo> Connect; /** * Edges define a mapping from a node which is connected over @@ -125,7 +162,7 @@ public: * provides a link between the target node of the Connect.Port * and the TargetNode.Port */ - typedef std::map <IVdfnNode*, std::list<Connect> > Edges; + typedef std::map < IVdfnNode*, std::list<Connect> > Edges; /** * A list of exported ports. @@ -140,7 +177,7 @@ public: // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /** - * @param nTimeStamp provide a timestamp that is passed as update time + * @param nTimeStamp provide a time stamp that is passed as update time stamp to all nodes that are evaluated. Pass 0 here for the initial build which will build up the edges and will call the PrepareEvaluationRun() @@ -159,7 +196,7 @@ public: * If a graph is deactivated, it runs over <b>all</b> nodes in the graph * and calls IVdfnNode::OnDeactivate() on them, passing dTimeStamp. * @param bIsActive true if this graph is marked active, false else - * @param dTimeStamp a timestamp, 0 for "force-state-propagation-to-nodes" + * @param dTimeStamp a time stamp, 0 for "force-state-propagation-to-nodes" */ void SetIsActive( bool bIsActive, double dTimeStamp ); @@ -189,10 +226,10 @@ public: // NODE MANAGEMENT // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /** - * Adds a node to this graph. This has no direct conseqeuence. + * Adds a node to this graph. This has no direct consequence. * It is not checked, whether the node is already part of this graph. - * The graph is markes dirty when a node is added. On the next request - * to evaluate the graph, the internal traversal stuctures will be rebuild. + * The graph is marked dirty when a node is added. On the next request + * to evaluate the graph, the internal traversal structures will be rebuild. * @return always true * @param pNode the node to be added for evaluation */ @@ -212,7 +249,7 @@ public: * Searches a node in this graph by name. Note that is is assumes that any * node in this graph has a unique name. * The node is searched by a case-sensitive comparison to the node name. - * @return NULL iff a node with nam strName was not found in this graph. + * @return NULL iff a node with name strName was not found in this graph. * @param strName the case sensitive name to be searched for. */ IVdfnNode *GetNodeByName(const std::string &strName) const; @@ -297,7 +334,7 @@ public: /** * control API, it tells the serializer of this graph to respect the * IVdfnNode::GetIsMasterSim() flag or not. If this method returns - * fallse, the master sim flag can be ignored during serialization, which + * false, the master sim flag can be ignored during serialization, which * will then dump <b>all</b> nodes of this graph, * not only the ones sitting on the master. * @see SetCheckMasterSim() @@ -327,27 +364,62 @@ private: typedef std::vector<IVdfnNode*> NodeVec; protected: + /** + * @brief evaluates nodes in the given vector, passing nTimeStamp as argument. + */ bool EvaluateSubGraph( const NodeVec& vecSubGraph, const double nTimeStamp ); + /** + * @brief helper method to build the graph traversal vector out of the + * set of given nodes and their connection based on port links. + */ bool UpdateTraversalVector(); - bool UpdatePortLookupMap(); + + /** + * @brief helper method to build an outport-cache when building the traversal + * structure. This map allows to lookup outports based on pointers + * quicker than a node/port lookup. This is needed for establishing + * a backlink structure for edge creation. + */ + bool UpdateOutportLookupMap(); + + /** + * @brief create connect information based on port links, i.e., edges between + * ports. + */ bool UpdateEdgeMap(); - bool UpdatePorts(); + + /** + * @brief calls PreparePorts() for all nodes in the traversal map. + * If a node reports that it can not be prepared, it is disabled. + */ + void PrepareAllPorts(); private: - Connect &GetAdjacencyList( IVdfnNode *, IVdfnPort * ); + /** + * @brief retrieves or generates the outward connect information + * for the given node and port. + */ + Connect &GetOrCreateAdjacencyListForNode( IVdfnNode *, IVdfnPort * ); + // all nodes contained in this graph Nodes m_liNodes; + // ordered list of nodes to be traversed NodeVec m_vecTraversal; + // edge / connection lookup table Edges m_mpEdges; + // cache to speed up lookup of outports during edge creation PortLookup m_mpPortLookup; + + // cache to process re-evaluation nodes as subgraphs std::map<IVdfnReEvalNode*, NodeVec> m_mpReEvalSubgraphs; + // exports defined for this graph ExportList m_liExports; - bool m_bUpToDate, - m_bIsActive, - m_bCheckMasterSim; + bool m_bUpToDate, // flag to show dirty (false) / clean state (true) + m_bIsActive, // global activation flag + m_bCheckMasterSim; // toggle to care for master sim evaluation }; /*============================================================================*/ diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnLoggerNode.cpp b/VistaCoreLibs/VistaDataFlowNet/VdfnLoggerNode.cpp index 8eaede7ede3c2d0d6b1d02a011fb3e7060a83f93..18d857ac570bec8567efb221ea26691f2b7be5e0 100644 --- a/VistaCoreLibs/VistaDataFlowNet/VdfnLoggerNode.cpp +++ b/VistaCoreLibs/VistaDataFlowNet/VdfnLoggerNode.cpp @@ -161,24 +161,25 @@ bool VdfnLoggerNode::PrepareEvaluationRun() std::list<std::string> liPortNames; std::map<IVdfnPort*, std::string> lostNames; - std::set<IVdfnPort*> Ports, SetPorts, DiffPorts; + std::set< std::pair<std::string, IVdfnPort*> > Ports, SetPorts, DiffPorts; for(PortMap::const_iterator it = m_mpInPorts.begin(); it != m_mpInPorts.end(); ++it ) { if( (*it).second == m_pFileName ) continue; // skip diz... - Ports.insert( (*it).second ); + Ports.insert( std::pair<std::string, IVdfnPort*>( (*it).first, (*it).second) ); } for(std::list<std::string>::const_iterator cit = m_liInPorts.begin(); cit != m_liInPorts.end(); ++cit) { - TVdfnPort<std::string> *pPort = VdfnUtil::GetInPortTyped<TVdfnPort<std::string>*>( *cit, this ); + TVdfnPort<std::string> *pPort + = VdfnUtil::GetInPortTyped<TVdfnPort<std::string>*>( *cit, this ); if(pPort) { m_vecPorts.push_back( pPort ); - SetPorts.insert( pPort ); + SetPorts.insert( std::pair<std::string,IVdfnPort*> ( *cit, pPort ) ); } else { @@ -196,20 +197,19 @@ bool VdfnLoggerNode::PrepareEvaluationRun() SetPorts.begin(), SetPorts.end(), std::inserter( DiffPorts, DiffPorts.end() ) ); - for( std::set<IVdfnPort*>::const_iterator dit = DiffPorts.begin(); - dit != DiffPorts.end(); ++dit ) + for( std::set< std::pair<std::string, IVdfnPort*> >::const_iterator dit + = DiffPorts.begin(); + dit != DiffPorts.end(); ++dit ) { - TVdfnPort<std::string> *pPort = dynamic_cast<TVdfnPort<std::string>*>( *dit ); + TVdfnPort<std::string> *pPort + = dynamic_cast<TVdfnPort<std::string>*>( (*dit).second ); if(pPort) - { m_vecPorts.push_back( pPort ); - } else m_vecPorts.push_back( m_pNotSet ); - std::string strName; - if(GetNameForInPort( pPort, strName )) - liPortNames.push_back(strName); + if( GetHasInPort( (*dit).first ) ) + liPortNames.push_back( (*dit).first ); else { std::map<IVdfnPort*, std::string>::const_iterator lnit = lostNames.find( pPort ); diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnNode.cpp b/VistaCoreLibs/VistaDataFlowNet/VdfnNode.cpp index 55775f44be2b52d54459cd5a1286e05e7dc52925..984a56df43d47cfe5806ecdf884755b37445c9cf 100644 --- a/VistaCoreLibs/VistaDataFlowNet/VdfnNode.cpp +++ b/VistaCoreLibs/VistaDataFlowNet/VdfnNode.cpp @@ -259,20 +259,6 @@ IVdfnPort *IVdfnNode::GetOutPort(const std::string &sName) const return (*cit).second; } -bool IVdfnNode::GetNameForInPort( IVdfnPort *pPort, std::string &strName ) const -{ - // reverse lookup in m_mpInPortMap - for(PortMap::const_iterator cit = m_mpInPorts.begin(); - cit != m_mpInPorts.end(); ++cit) - { - if( (*cit).second == pPort ) - { - strName = (*cit).first; - return true; - } - } - return false; -} bool IVdfnNode::GetNameForOutPort( IVdfnPort *pPort, std::string &strName ) const { diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnNode.h b/VistaCoreLibs/VistaDataFlowNet/VdfnNode.h index 028acc6bb4778ed4eb2dda8c1fdba8b521b89dda..436e0785cc9e02deecd1959ea5d71665bc04349a 100644 --- a/VistaCoreLibs/VistaDataFlowNet/VdfnNode.h +++ b/VistaCoreLibs/VistaDataFlowNet/VdfnNode.h @@ -200,16 +200,6 @@ public: */ virtual bool RemInPort(const std::string &sName); - /** - * Retrieve a name for an inport. - * @param pPort the port to lookup in the inport map - * @param strName the container to store the name to - * @return true iff the port exists as inport, false if this pPort could not - be retrieved from the set of inports. - * @see GetNameForOutPort() - */ - bool GetNameForInPort( IVdfnPort *pPort, std::string &strName ) const; - /** * Retrieve a name for an outport. * @param pPort the port to lookup in the outport map diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnPersistence.cpp b/VistaCoreLibs/VistaDataFlowNet/VdfnPersistence.cpp index 7ec5698a20dbb89bc9f4a51a9b6295ac30c3cd8b..b31bbb9e78a0d40b3c61c323e434728fb1f78ec2 100644 --- a/VistaCoreLibs/VistaDataFlowNet/VdfnPersistence.cpp +++ b/VistaCoreLibs/VistaDataFlowNet/VdfnPersistence.cpp @@ -1150,11 +1150,8 @@ bool VdfnPersistence::SaveAsDot( VdfnGraph *pGraph, (*cit)->GetNameForOutPort( (*t).first, strFromPortName ); - std::string strToPortName; - if((*nit).first->GetNameForInPort( (*nit).second, strToPortName ) == false) - { - vstr::warnp() << "VdfnPersistence::SaveAsDot() - No port given" << std::endl; - } + std::string strToPortName = (*nit).second.first; + if( bWritePorts || bWriteValues ) { std::string strNodeName = CleanNodeName((*cit)->GetNameForNameable());