Uses of Class
uk.ed.inf.graph.compound.base.BaseCompoundNode

Packages that use BaseCompoundNode
uk.ed.inf.graph.compound.archetypal   
uk.ed.inf.graph.compound.base   
uk.ed.inf.graph.compound.impl   
 

Uses of BaseCompoundNode in uk.ed.inf.graph.compound.archetypal
 

Subclasses of BaseCompoundNode in uk.ed.inf.graph.compound.archetypal
 class ArchetypalCompoundNode
           
 

Methods in uk.ed.inf.graph.compound.archetypal that return types with arguments of type BaseCompoundNode
protected  ITree<BaseCompoundNode> ArchetypalCompoundGraph.getNodeTree()
           
 

Methods in uk.ed.inf.graph.compound.archetypal with parameters of type BaseCompoundNode
protected  void ArchetypalChildCompoundGraph.addNewNode(BaseCompoundNode node)
           
protected abstract  void ArchetypalCompoundGraph.createCopyOfRootNode(int newIndexValue, BaseCompoundNode otherRootNode)
           
 

Uses of BaseCompoundNode in uk.ed.inf.graph.compound.base
 

Methods in uk.ed.inf.graph.compound.base that return BaseCompoundNode
protected abstract  BaseCompoundNode BaseGraphCopyBuilder.createCopyOfNode(BaseCompoundNode srcNode, BaseCompoundNode destParentNode)
          Create a compound node.
protected abstract  BaseCompoundNode BaseGraphMoveBuilder.createMoveOfNode(BaseCompoundNode srcNode, BaseCompoundNode destParentNode)
          Create a compound node.
 BaseCompoundNode BaseCompoundNodeFactory.createNode()
           
protected  BaseCompoundNode BaseGraphCopyBuilder.getCopiedNode(BaseCompoundNode originalNode)
          Gets the equivalent copied node to the specified node, if it exists.
abstract  BaseCompoundNode BaseCompoundNodePair.getInNode()
           
protected abstract  BaseCompoundNode BaseCompoundEdgeFactory.getInNode()
           
protected abstract  BaseCompoundNode BaseCompoundEdge.getInNode()
           
protected abstract  BaseCompoundNode BaseChildCompoundEdgeFactory.getInNode()
           
(package private)  BaseCompoundNode BaseCompoundGraph.getLcaNode(BaseCompoundNode inNode, BaseCompoundNode outNode)
           
 BaseCompoundNode BaseSubCompoundGraph.getNode(int nodeIdx)
           
 BaseCompoundNode BaseCompoundGraph.getNode(int nodeIdx)
           
 BaseCompoundNode BaseChildCompoundGraph.getNode(int nodeIdx)
           
 BaseCompoundNode BaseCompoundNodePair.getOneNode()
           
 BaseCompoundNode BaseCompoundNodePair.getOtherNode(BaseCompoundNode node)
           
abstract  BaseCompoundNode BaseCompoundNodePair.getOutNode()
           
protected abstract  BaseCompoundNode BaseCompoundEdgeFactory.getOutNode()
           
protected abstract  BaseCompoundNode BaseCompoundEdge.getOutNode()
           
protected abstract  BaseCompoundNode BaseChildCompoundEdgeFactory.getOutNode()
           
abstract  BaseCompoundNode BaseCompoundNode.getParent()
          The parent node cannot be null and should be the root node if the current node is the root node.
abstract  BaseCompoundNode BaseCompoundNodeFactory.getParentNode()
           
 BaseCompoundNode BaseCompoundNode.getRoot()
           
abstract  BaseCompoundNode BaseCompoundGraph.getRootNode()
           
abstract  BaseCompoundNode BaseChildCompoundGraph.getRootNode()
           
 BaseCompoundNode BaseCompoundNodePair.getTwoNode()
           
protected abstract  BaseCompoundNode BaseCompoundNodeFactory.newNode(BaseCompoundNode parent, int nodeIndex)
          Creates the new node.
 

Methods in uk.ed.inf.graph.compound.base that return types with arguments of type BaseCompoundNode
 java.util.Iterator<BaseCompoundNode> BaseCompoundNode.ancestorIterator()
           
 java.util.Iterator<BaseCompoundNode> BaseCompoundNode.childIterator()
           
 java.util.Iterator<BaseCompoundNode> BaseCompoundNode.connectedNodeIterator()
           
 IGraphState<BaseCompoundNode,BaseCompoundEdge> BaseCompoundGraphStateHandler.createGraphState()
           
 IDirectedPair<BaseCompoundNode,BaseCompoundEdge> BaseCompoundEdge.getConnectedNodes()
           
 ISubCompoundGraph<BaseCompoundNode,BaseCompoundEdge> BaseCompoundGraph.getCopiedComponents()
           
 IGraphState<BaseCompoundNode,BaseCompoundEdge> BaseCompoundGraph.getCurrentState()
           
protected  IFilteredEdgeSet<BaseCompoundNode,BaseCompoundEdge> BaseCompoundNode.getEdgeInList()
           
protected  IFilteredEdgeSet<BaseCompoundNode,BaseCompoundEdge> BaseCompoundNode.getEdgeOutList()
           
protected  IEdgeSet<BaseCompoundNode,BaseCompoundEdge> BaseChildCompoundGraph.getEdgeSet()
           
 ICompoundGraph<BaseCompoundNode,BaseCompoundEdge> BaseCompoundGraphStateHandler.getGraph()
           
 java.util.Iterator<BaseCompoundNode> BaseCompoundNode.getInNodeIterator()
           
protected  java.util.Set<BaseCompoundNode> BaseSubCompoundGraphBuilder.getNodeList()
           
protected  INodeSet<BaseCompoundNode,BaseCompoundEdge> BaseChildCompoundGraph.getNodeSet()
           
protected abstract  ITree<BaseCompoundNode> BaseCompoundGraph.getNodeTree()
           
 java.util.Iterator<BaseCompoundNode> BaseCompoundNode.getOutNodeIterator()
           
 java.util.Iterator<BaseCompoundNode> BaseCompoundNode.levelOrderIterator()
           
 java.util.Iterator<BaseCompoundNode> BaseSubCompoundGraphFactory.nodeIterator()
          Get an iterator for the set of nodes added to this factory.
 java.util.Iterator<BaseCompoundNode> BaseSubCompoundGraph.nodeIterator()
           
 java.util.Iterator<BaseCompoundNode> BaseCompoundGraph.nodeIterator()
           
 java.util.Iterator<BaseCompoundNode> BaseChildCompoundGraph.nodeIterator()
           
 java.util.Iterator<BaseCompoundNode> BaseSubCompoundGraph.topNodeIterator()
           
protected  java.util.Iterator<BaseCompoundNode> BaseChildCompoundGraph.unfilteredNodeIterator()
           
 

Methods in uk.ed.inf.graph.compound.base with parameters of type BaseCompoundNode
protected  void BaseChildCompoundGraph.addNewNode(BaseCompoundNode newNode)
           
 void BaseSubCompoundGraphFactory.addNode(BaseCompoundNode node)
           
(package private)  void BaseSubCompoundGraph.addTopNode(BaseCompoundNode newNode)
           
 int BaseCompoundNode.compareTo(BaseCompoundNode o)
           
 boolean BaseSubCompoundGraph.containsConnection(BaseCompoundNode thisNode, BaseCompoundNode thatNode)
           
 boolean BaseCompoundGraph.containsConnection(BaseCompoundNode thisNode, BaseCompoundNode thatNode)
           
 boolean BaseChildCompoundGraph.containsConnection(BaseCompoundNode thisNode, BaseCompoundNode thatNode)
           
 boolean BaseSubCompoundGraph.containsDirectedEdge(BaseCompoundNode outNode, BaseCompoundNode inNode)
           
 boolean BaseCompoundGraph.containsDirectedEdge(BaseCompoundNode outNode, BaseCompoundNode inNode)
           
 boolean BaseChildCompoundGraph.containsDirectedEdge(BaseCompoundNode outNode, BaseCompoundNode inNode)
           
 boolean BaseSubCompoundGraph.containsNode(BaseCompoundNode node)
           
 boolean BaseCompoundNodePair.containsNode(BaseCompoundNode node)
           
 boolean BaseCompoundGraph.containsNode(BaseCompoundNode node)
           
 boolean BaseChildCompoundGraph.containsNode(BaseCompoundNode node)
           
protected abstract  BaseCompoundEdge BaseGraphCopyBuilder.createCopyOfEdge(BaseCompoundEdge srcEdge, BaseChildCompoundGraph edgeOwner, BaseCompoundNode outNode, BaseCompoundNode inNode)
          Create a new edge that us a copy of another, which may be in a different graph this this one.
protected abstract  BaseCompoundNode BaseGraphCopyBuilder.createCopyOfNode(BaseCompoundNode srcNode, BaseCompoundNode destParentNode)
          Create a compound node.
protected abstract  void BaseCompoundGraph.createCopyOfRootNode(int newIndexValue, BaseCompoundNode otherRootNode)
           
protected abstract  BaseCompoundEdge BaseGraphMoveBuilder.createMoveOfEdge(BaseCompoundEdge srcEdge, BaseChildCompoundGraph edgeOwner, BaseCompoundNode outNode, BaseCompoundNode inNode)
          Create a new edge that us a copy of another, which may be in a different graph this this one.
protected abstract  BaseCompoundNode BaseGraphMoveBuilder.createMoveOfNode(BaseCompoundNode srcNode, BaseCompoundNode destParentNode)
          Create a compound node.
protected  BaseCompoundNode BaseGraphCopyBuilder.getCopiedNode(BaseCompoundNode originalNode)
          Gets the equivalent copied node to the specified node, if it exists.
 java.util.SortedSet<BaseCompoundEdge> BaseCompoundNode.getEdgesWith(BaseCompoundNode other)
           
 java.util.SortedSet<BaseCompoundEdge> BaseCompoundNode.getInEdgesFrom(BaseCompoundNode outNode)
           
(package private)  BaseCompoundNode BaseCompoundGraph.getLcaNode(BaseCompoundNode inNode, BaseCompoundNode outNode)
           
 BaseCompoundNode BaseCompoundNodePair.getOtherNode(BaseCompoundNode node)
           
 java.util.SortedSet<BaseCompoundEdge> BaseCompoundNode.getOutEdgesTo(BaseCompoundNode inNode)
           
 boolean BaseCompoundNodePair.hasDirectedEnds(BaseCompoundNode outNode, BaseCompoundNode inNode)
           
 boolean BaseCompoundNode.hasEdgeWith(BaseCompoundNode other)
           
 boolean BaseCompoundNodePair.hasEnds(BaseCompoundNode endOne, BaseCompoundNode endTwo)
           
 boolean BaseCompoundNode.hasInEdgeFrom(BaseCompoundNode outNode)
           
 boolean BaseCompoundNode.hasOutEdgeTo(BaseCompoundNode inNode)
           
 boolean BaseCompoundNode.isAncestor(BaseCompoundNode testNode)
           
 boolean BaseCompoundNode.isChild(BaseCompoundNode childNode)
           
 boolean BaseCompoundNode.isDescendent(BaseCompoundNode testNode)
           
 boolean BaseCompoundNode.isParent(BaseCompoundNode parentNode)
           
protected  boolean BaseChildCompoundEdgeFactory.isValidBaseNodePair(BaseCompoundNode outNode, BaseCompoundNode inNode)
          Methods implementing the isValidNodePair() should call this method in addition to carrying out it's own checks.
protected abstract  BaseCompoundEdge BaseCompoundEdgeFactory.newEdge(BaseChildCompoundGraph owningGraph, int nodeIndex, BaseCompoundNode outNode, BaseCompoundNode inNode)
           
protected abstract  BaseCompoundEdge BaseChildCompoundEdgeFactory.newEdge(BaseChildCompoundGraph owningChildGraph, int edgeIndex, BaseCompoundNode outNode, BaseCompoundNode inNode)
           
protected abstract  BaseCompoundNode BaseCompoundNodeFactory.newNode(BaseCompoundNode parent, int nodeIndex)
          Creates the new node.
abstract  void BaseCompoundEdgeFactory.setPair(BaseCompoundNode outNode, BaseCompoundNode inNode)
           
abstract  void BaseChildCompoundEdgeFactory.setPair(BaseCompoundNode outNode, BaseCompoundNode inNode)
           
 

Method parameters in uk.ed.inf.graph.compound.base with type arguments of type BaseCompoundNode
 boolean BaseCompoundGraph.canCopyHere(ISubCompoundGraph<? extends BaseCompoundNode,? extends BaseCompoundEdge> subGraph)
           
 boolean BaseChildCompoundGraph.canCopyHere(ISubCompoundGraph<? extends BaseCompoundNode,? extends BaseCompoundEdge> subGraph)
           
 boolean BaseChildCompoundGraph.canMoveHere(ISubCompoundGraph<? extends BaseCompoundNode,? extends BaseCompoundEdge> iSubGraph)
          Tests whether the subGraph can be moved to this graph.
 boolean BaseCompoundGraph.canRemoveSubgraph(ISubCompoundGraph<? extends BaseCompoundNode,? extends BaseCompoundEdge> subgraph)
           
 boolean BaseSubCompoundGraph.containsConnection(IBasicPair<? extends BaseCompoundNode,? extends BaseCompoundEdge> ends)
          Tests if the ends define any edge in this graph.
 boolean BaseCompoundGraph.containsConnection(IBasicPair<? extends BaseCompoundNode,? extends BaseCompoundEdge> ends)
          Tests if the ends define any edge in this graph.
 boolean BaseChildCompoundGraph.containsConnection(IBasicPair<? extends BaseCompoundNode,? extends BaseCompoundEdge> ends)
           
 boolean BaseSubCompoundGraph.containsDirectedEdge(IDirectedPair<? extends BaseCompoundNode,? extends BaseCompoundEdge> ends)
          Tests if the ends define one or more directed edges.
 boolean BaseCompoundGraph.containsDirectedEdge(IDirectedPair<? extends BaseCompoundNode,? extends BaseCompoundEdge> ends)
          Tests if the ends define one or more directed edges.
 boolean BaseChildCompoundGraph.containsDirectedEdge(IDirectedPair<? extends BaseCompoundNode,? extends BaseCompoundEdge> ends)
           
 void BaseCompoundGraph.copyHere(ISubCompoundGraph<? extends BaseCompoundNode,? extends BaseCompoundEdge> subGraph)
           
 void BaseChildCompoundGraph.copyHere(ISubCompoundGraph<? extends BaseCompoundNode,? extends BaseCompoundEdge> subGraph)
           
protected  void BaseSubCompoundGraph.createEdgeSet(IDirectedEdgeSet<BaseCompoundNode,BaseCompoundEdge> edgeSet)
           
protected  void BaseChildCompoundGraph.createEdgeSet(IDirectedEdgeSet<BaseCompoundNode,BaseCompoundEdge> edgeSet)
           
protected  void BaseCompoundNode.createInEdgeSet(IDirectedEdgeSet<BaseCompoundNode,BaseCompoundEdge> edgeSet)
           
protected  void BaseSubCompoundGraph.createNodeSet(INodeSet<BaseCompoundNode,BaseCompoundEdge> nodeSet)
           
protected  void BaseChildCompoundGraph.createNodeSet(INodeSet<BaseCompoundNode,BaseCompoundEdge> nodeSet)
           
protected  void BaseCompoundNode.createOutEdgeSet(IDirectedEdgeSet<BaseCompoundNode,BaseCompoundEdge> edgeSet)
           
 boolean BaseCompoundEdge.hasDirectedEnds(IDirectedPair<? super BaseCompoundNode,? super BaseCompoundEdge> ends)
           
 boolean BaseCompoundEdge.hasEnds(IBasicPair<? super BaseCompoundNode,? super BaseCompoundEdge> ends)
           
 void BaseChildCompoundGraph.moveHere(ISubCompoundGraph<? extends BaseCompoundNode,? extends BaseCompoundEdge> subGraph)
          Moves a subgraph into this graph.
 void BaseCompoundGraph.removeSubgraph(ISubCompoundGraph<? extends BaseCompoundNode,? extends BaseCompoundEdge> subgraph)
           
 void BaseCompoundGraphStateHandler.restoreState(IGraphState<BaseCompoundNode,BaseCompoundEdge> previousState)
           
 void BaseCompoundGraph.restoreState(IGraphState<BaseCompoundNode,BaseCompoundEdge> previousState)
           
 void BaseGraphMoveBuilder.setDestinatChildCompoundGraph(IChildCompoundGraph<? extends BaseCompoundNode,? extends BaseCompoundEdge> childCompoundGraph)
           
 void BaseGraphCopyBuilder.setDestinatChildCompoundGraph(IChildCompoundGraph<? extends BaseCompoundNode,? extends BaseCompoundEdge> childCompoundGraph)
           
 void BaseSubCompoundGraphBuilder.setNodeList(java.util.Set<? extends BaseCompoundNode> nodeList)
           
 void BaseGraphMoveBuilder.setSourceSubgraph(ISubCompoundGraph<? extends BaseCompoundNode,? extends BaseCompoundEdge> sourceSubCompoundGraph)
           
 void BaseGraphCopyBuilder.setSourceSubgraph(ISubCompoundGraph<? extends BaseCompoundNode,? extends BaseCompoundEdge> sourceSubCompoundGraph)
           
 

Constructor parameters in uk.ed.inf.graph.compound.base with type arguments of type BaseCompoundNode
BaseCompoundGraphStateHandler(ICompoundGraph<BaseCompoundNode,BaseCompoundEdge> graph)
           
 

Uses of BaseCompoundNode in uk.ed.inf.graph.compound.impl
 

Subclasses of BaseCompoundNode in uk.ed.inf.graph.compound.impl
 class CompoundNode
           
 

Methods in uk.ed.inf.graph.compound.impl that return BaseCompoundNode
protected  BaseCompoundNode CompoundGraphCopyBuilder.createCopyOfNode(BaseCompoundNode srcNode, BaseCompoundNode destParentNode)
           
protected  BaseCompoundNode CompoundGraphMoveBuilder.createMoveOfNode(BaseCompoundNode srcNode, BaseCompoundNode destParentNode)
           
 BaseCompoundNode CompoundNodePair.getInNode()
           
protected  BaseCompoundNode CompoundEdgeFactory.getInNode()
           
 BaseCompoundNode CompoundNodePair.getOutNode()
           
protected  BaseCompoundNode CompoundEdgeFactory.getOutNode()
           
 BaseCompoundNode CompoundNodeFactory.getParentNode()
           
 

Methods in uk.ed.inf.graph.compound.impl with parameters of type BaseCompoundNode
protected  BaseCompoundEdge CompoundGraphCopyBuilder.createCopyOfEdge(BaseCompoundEdge srcEdge, BaseChildCompoundGraph edgeOwner, BaseCompoundNode outNode, BaseCompoundNode inNode)
           
protected  BaseCompoundNode CompoundGraphCopyBuilder.createCopyOfNode(BaseCompoundNode srcNode, BaseCompoundNode destParentNode)
           
protected  void CompoundGraph.createCopyOfRootNode(int newIndexValue, BaseCompoundNode otherRootNode)
           
protected  BaseCompoundEdge CompoundGraphMoveBuilder.createMoveOfEdge(BaseCompoundEdge srcEdge, BaseChildCompoundGraph edgeOwner, BaseCompoundNode outNode, BaseCompoundNode inNode)
           
protected  BaseCompoundNode CompoundGraphMoveBuilder.createMoveOfNode(BaseCompoundNode srcNode, BaseCompoundNode destParentNode)
           
 boolean CompoundEdgeFactory.isValidNodePair(BaseCompoundNode outNode, BaseCompoundNode inNode)
           
 boolean ChildCompoundEdgeFactory.isValidNodePair(BaseCompoundNode outNode, BaseCompoundNode inNode)
           
protected  ArchetypalCompoundEdge CompoundEdgeFactory.newEdge(BaseChildCompoundGraph owningGraph, int nodeIndex, BaseCompoundNode outNode, BaseCompoundNode inNode)
           
protected  ArchetypalCompoundEdge ChildCompoundEdgeFactory.newEdge(BaseChildCompoundGraph owningChildGraph, int edgeIndex, BaseCompoundNode outNode, BaseCompoundNode inNode)
           
 CompoundNode CompoundNodeFactory.newNode(BaseCompoundNode parent, int nodeIndex)
           
 void CompoundEdgeFactory.setPair(BaseCompoundNode outNode, BaseCompoundNode inNode)
           
 void ChildCompoundEdgeFactory.setPair(BaseCompoundNode outNode, BaseCompoundNode inNode)