net.walend.digraph.path
Class AbstractDelegateDigraphOfGEPaths.DigraphGEPath

java.lang.Object
  |
  +--net.walend.digraph.path.AbstractDelegateDigraphOfGEPaths.DigraphGEPath

All Implemented Interfaces:

Digraph, GEDigraph, GEPath, HasState, Path

Direct Known Subclasses:

AbstractShortestGEPaths.DigraphMeasuredGEPath

Enclosing class:

AbstractDelegateDigraphOfGEPaths

protected static class AbstractDelegateDigraphOfGEPaths.DigraphGEPath

extends java.lang.Object

implements GEPath

Nested Class Summary

protected class	AbstractDelegateDigraphOfGEPaths.DigraphGEPath.PathEdgeNodeIterator
private class	AbstractDelegateDigraphOfGEPaths.DigraphGEPath.PathNodeIterator

Field Summary

private AbstractDelegateDigraphOfGEPaths	container
private AbstractDelegateDigraphOfGEPaths.Edge	edge
private java.lang.Object	head
private java.lang.Object	tail

Fields inherited from interface net.walend.digraph.GEDigraph

EMPTY

Constructor Summary

AbstractDelegateDigraphOfGEPaths.DigraphGEPath(java.lang.Object head, AbstractDelegateDigraphOfGEPaths.Edge edge, java.lang.Object tail, AbstractDelegateDigraphOfGEPaths container)

Method Summary

private void	checkEdge(java.lang.Object edge)
private void	checkEdgeIndex(int index)
private void	checkIndices(int startNodeIndex, int endNodeIndex)
private void	checkNode(java.lang.Object node)
private void	checkNodeIndex(int index)
boolean	containsEdge(java.lang.Object fromNode, java.lang.Object toNode) Returns true if edge links fromNode to toNode
boolean	containsGEDigraph(GEDigraph digraph) Returns true if digraph is a subgraph of this GEDigraph.
boolean	containsNode(java.lang.Object node)
boolean	containsNodes(java.util.Set nodes)
int	countInboundEdges(java.lang.Object node)
int	countOutboundEdges(java.lang.Object node)
int	edgeCount()
EdgeNodeIterator	edgeNodeIterator() Returns an iterator that iterates across pairs of nodes that make edges.
java.util.Set	getFromNodes(java.lang.Object node) Returns the set of nodes that can reach this node by crossing one edge.
java.lang.Object	getHead()
int	getIndexOfNode(java.lang.Object node)
int	getLastIndexOfNode(java.lang.Object node)
java.lang.Object	getNeck()
java.lang.Object	getNodeAtIndex(int index)
java.util.List	getNodeList() Returns an immutable list of the nodes.
java.util.Set	getNodes()
java.lang.Class	getPrincipleInterface() Returns the class's principle interface for state comparisons.
GEPath	getSubpath(int startNodeIndex, int endNodeIndex) Returns a new path, between startNodeIndex and endNodeIndex, inclusive.
private GEPath	getSubpath(java.lang.Object startNode, java.lang.Object endNode)
GEPath	getSubpathFirst(java.lang.Object startNode, java.lang.Object endNode) Returns a new path, between the first occurence of startNode and the first occurence of endNode, inclusive.
GEPath	getSubpathFirstToLast(java.lang.Object startNode, java.lang.Object endNode) Returns a new path, between the first occurence of startNode and the last occurence of endNode, inclusive.
GEPath	getSubpathLast(java.lang.Object startNode, java.lang.Object endNode) Returns a new path, between the last occurence of startNode and the last occurence of endNode, inclusive.
GEPath	getSubpathLastToFirst(java.lang.Object startNode, java.lang.Object endNode) Returns a new path, between the last occurence of startNode and the first occurence of endNode, inclusive.
GEDigraph	getSupergraph() Returns the base.
java.lang.Object	getTail()
java.util.Set	getToNodes(java.lang.Object node) Returns the set of nodes that can be reached from this node by crossing one edge.
GEDigraph	intersectWithGEDigraph(GEDigraph digraph) Returns a new digraph that is the intersection of this with digraph.
boolean	isEdgeFree() Returns true if this Digraph has no edges.
boolean	isEmpty()
int	nodeCount()
java.util.Iterator	nodeIterator() Implementations should explicitly state how they interpret nodeIterator()'s remove method.
int	pathEdgeCount() Returns the number of edges in the path, including repeates.
EdgeNodeIterator	pathEdgeNodeIterator() Iterate through the edges in path order.
int	pathNodeCount() Returns the number of nodes in the path, including repeates.
java.util.Iterator	pathNodeIterator() Implementations should explicitly state how they interpret nodeIterator()'s remove method.
boolean	sameGEDigraphAs(GEDigraph digraph) Returns true if digraph is the same as this, and all their contents have the same state.
boolean	sameGEPathAs(GEPath path) Returns true if path is the same path as this, on the same digraph.
boolean	sameStateAs(HasState victim) If two HasStates have the same internal state, return true.
java.lang.String	toString()
GEDigraph	unionGEDigraph(GEDigraph digraph) Returns a new digraph that is the union of this with digraph.
boolean	valid() Returns true if this path is still a subgraph of its supergraph

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

edge

private AbstractDelegateDigraphOfGEPaths.Edge edge

head

private java.lang.Object head

tail

private java.lang.Object tail

container

private AbstractDelegateDigraphOfGEPaths container

Constructor Detail

AbstractDelegateDigraphOfGEPaths.DigraphGEPath

public AbstractDelegateDigraphOfGEPaths.DigraphGEPath(java.lang.Object head,
                                                      AbstractDelegateDigraphOfGEPaths.Edge edge,
                                                      java.lang.Object tail,
                                                      AbstractDelegateDigraphOfGEPaths container)

Method Detail

getNeck

public java.lang.Object getNeck()

getSupergraph

public GEDigraph getSupergraph()

Returns the base.

Specified by:

getSupergraph in interface GEPath

checkEdge

private void checkEdge(java.lang.Object edge)

checkEdgeIndex

private void checkEdgeIndex(int index)

checkNodeIndex

private void checkNodeIndex(int index)

checkIndices

private void checkIndices(int startNodeIndex,
                          int endNodeIndex)
                   throws InvalidSpliceException

InvalidSpliceException

getSubpath

public GEPath getSubpath(int startNodeIndex,
                         int endNodeIndex)
                  throws InvalidSpliceException

Returns a new path, between startNodeIndex and endNodeIndex, inclusive.

Specified by:

getSubpath in interface GEPath

InvalidSpliceException

getSubpath

private GEPath getSubpath(java.lang.Object startNode,
                          java.lang.Object endNode)
                   throws NodeMissingException,
                          InvalidSpliceException

NodeMissingException

InvalidSpliceException

getSubpathFirst

public GEPath getSubpathFirst(java.lang.Object startNode,
                              java.lang.Object endNode)
                       throws NodeMissingException,
                              InvalidSpliceException

Returns a new path, between the first occurence of startNode and the first occurence of endNode, inclusive.

Specified by:

getSubpathFirst in interface GEPath

Throws:

NodeMissingException - if the nodes are not in the path.

InvalidSpliceException - if the nodes are not in the right order.

getSubpathLast

public GEPath getSubpathLast(java.lang.Object startNode,
                             java.lang.Object endNode)
                      throws NodeMissingException,
                             InvalidSpliceException

Returns a new path, between the last occurence of startNode and the last occurence of endNode, inclusive.

Specified by:

getSubpathLast in interface GEPath

Throws:

NodeMissingException - if the nodes are not in the path.

InvalidSpliceException - if the nodes are not in the right order.

getSubpathFirstToLast

public GEPath getSubpathFirstToLast(java.lang.Object startNode,
                                    java.lang.Object endNode)
                             throws NodeMissingException,
                                    InvalidSpliceException

Returns a new path, between the first occurence of startNode and the last occurence of endNode, inclusive.

Specified by:

getSubpathFirstToLast in interface GEPath

Throws:

NodeMissingException - if the nodes are not in the path.

InvalidSpliceException - if the nodes are not in the right order.

getSubpathLastToFirst

public GEPath getSubpathLastToFirst(java.lang.Object startNode,
                                    java.lang.Object endNode)
                             throws NodeMissingException,
                                    InvalidSpliceException

Returns a new path, between the last occurence of startNode and the first occurence of endNode, inclusive.

Specified by:

getSubpathLastToFirst in interface GEPath

Throws:

NodeMissingException - if the nodes are not in the path.

InvalidSpliceException - if the nodes are not in the right order.

sameGEPathAs

public boolean sameGEPathAs(GEPath path)

Returns true if path is the same path as this, on the same digraph. So if two paths are on different supergraphs, they may be the same digraph, but not the same path.

Specified by:

sameGEPathAs in interface GEPath

valid

public boolean valid()

Returns true if this path is still a subgraph of its supergraph

Specified by:

valid in interface Path

pathNodeCount

public int pathNodeCount()

Returns the number of nodes in the path, including repeates.

Specified by:

pathNodeCount in interface Path

pathEdgeCount

public int pathEdgeCount()

Returns the number of edges in the path, including repeates.

Specified by:

pathEdgeCount in interface Path

getHead

public java.lang.Object getHead()

Specified by:

getHead in interface Path

getTail

public java.lang.Object getTail()

Specified by:

getTail in interface Path

getNodeAtIndex

public java.lang.Object getNodeAtIndex(int index)

Specified by:

getNodeAtIndex in interface Path

getIndexOfNode

public int getIndexOfNode(java.lang.Object node)

Specified by:

getIndexOfNode in interface Path

getLastIndexOfNode

public int getLastIndexOfNode(java.lang.Object node)

Specified by:

getLastIndexOfNode in interface Path

getNodeList

public java.util.List getNodeList()

Returns an immutable list of the nodes.

Specified by:

getNodeList in interface Path

pathNodeIterator

public java.util.Iterator pathNodeIterator()

Implementations should explicitly state how they interpret nodeIterator()'s remove method. It should either throw an UnsupportedOperationException or cause a hidden side effect of removing edges.

The Iterator should start at the beginning of the path and iterate to the end.

Specified by:

pathNodeIterator in interface Path

pathEdgeNodeIterator

public EdgeNodeIterator pathEdgeNodeIterator()

Iterate through the edges in path order.

If Path is immutable, edgeNodeIterator()'s remove() method throws an UnsupportedOperationException.

Specified by:

pathEdgeNodeIterator in interface Path

containsEdge

public boolean containsEdge(java.lang.Object fromNode,
                            java.lang.Object toNode)
                     throws NodeMissingException

Returns true if edge links fromNode to toNode

Specified by:

containsEdge in interface Digraph

Throws:

NodeMissingException - if either node is missing from the digraph.

checkNode

private void checkNode(java.lang.Object node)
                throws NodeMissingException

NodeMissingException

containsGEDigraph

public boolean containsGEDigraph(GEDigraph digraph)

Returns true if digraph is a subgraph of this GEDigraph.

Specified by:

containsGEDigraph in interface GEDigraph

sameGEDigraphAs

public boolean sameGEDigraphAs(GEDigraph digraph)

Returns true if digraph is the same as this, and all their contents have the same state.

Specified by:

sameGEDigraphAs in interface GEDigraph

intersectWithGEDigraph

public GEDigraph intersectWithGEDigraph(GEDigraph digraph)

Returns a new digraph that is the intersection of this with digraph. Implementations should generally return the same implementation of GEDigraph as they have themselves.

Specified by:

intersectWithGEDigraph in interface GEDigraph

unionGEDigraph

public GEDigraph unionGEDigraph(GEDigraph digraph)

Returns a new digraph that is the union of this with digraph. Implementations should generally return the same implementation of GEDigraph as they are themselves. If the digraphs contain conflicting edges, then (unless you have a better rule) let digraph's edge win out.

Specified by:

unionGEDigraph in interface GEDigraph

nodeCount

public int nodeCount()

Specified by:

nodeCount in interface Digraph

edgeCount

public int edgeCount()

Specified by:

edgeCount in interface Digraph

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface Digraph

containsNode

public boolean containsNode(java.lang.Object node)

Specified by:

containsNode in interface Digraph

countInboundEdges

public int countInboundEdges(java.lang.Object node)
                      throws NodeMissingException

Specified by:

countInboundEdges in interface Digraph

Throws:

NodeMissingException - if node is not in the digraph.

countOutboundEdges

public int countOutboundEdges(java.lang.Object node)
                       throws NodeMissingException

Specified by:

countOutboundEdges in interface Digraph

Throws:

NodeMissingException - if node is not in the digraph.

getFromNodes

public java.util.Set getFromNodes(java.lang.Object node)
                           throws NodeMissingException

Returns the set of nodes that can reach this node by crossing one edge.

Specified by:

getFromNodes in interface Digraph

Throws:

NodeMissingException - if node is not in the digraph.

getToNodes

public java.util.Set getToNodes(java.lang.Object node)
                         throws NodeMissingException

Returns the set of nodes that can be reached from this node by crossing one edge.

Specified by:

getToNodes in interface Digraph

Throws:

NodeMissingException - if node is not in the digraph.

nodeIterator

public java.util.Iterator nodeIterator()

Implementations should explicitly state how they interpret nodeIterator()'s remove method. It should either throw an UnsupportedOperationException or cause a hidden side effects of removing edges.

Specified by:

nodeIterator in interface Digraph

edgeNodeIterator

public EdgeNodeIterator edgeNodeIterator()

Returns an iterator that iterates across pairs of nodes that make edges.

Specified by:

edgeNodeIterator in interface Digraph

getNodes

public java.util.Set getNodes()

Specified by:

getNodes in interface Digraph

isEdgeFree

public boolean isEdgeFree()

Returns true if this Digraph has no edges.

Specified by:

isEdgeFree in interface Digraph

containsNodes

public boolean containsNodes(java.util.Set nodes)

Specified by:

containsNodes in interface Digraph

getPrincipleInterface

public java.lang.Class getPrincipleInterface()

Description copied from interface: HasState

Returns the class's principle interface for state comparisons. If two objects have different principle interfaces, they never have the same state.

Specified by:

getPrincipleInterface in interface HasState

sameStateAs

public boolean sameStateAs(HasState victim)

Description copied from interface: HasState

If two HasStates have the same internal state, return true.

For objects with subobjects, Generally this method should only return true if the internal objects are equal. Implement a contentsHaveSameState() method to determine if the contents have the same state.

Specified by:

sameStateAs in interface HasState

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object