N
 Node parameter type@Beta @Immutable(containerOf="N") public class ImmutableGraph<N> extends AbstractGraph<N>
Graph
whose elements and structural relationships will never change. Instances of this
class may be obtained with copyOf(Graph)
.
See the Guava User's Guide's discussion
of the Immutable*
types for more information on the properties and guarantees
provided by this class.
Modifier and Type  Class and Description 

static class 
ImmutableGraph.Builder<N>
A builder for creating
ImmutableGraph instances, especially static final
graphs. 
Modifier and Type  Method and Description 

Set<N> 
adjacentNodes(N node)
Returns the nodes which have an incident edge in common with
node in this graph. 
boolean 
allowsSelfLoops()
Returns true if this graph allows selfloops (edges that connect a node to itself).

static <N> ImmutableGraph<N> 
copyOf(Graph<N> graph)
Returns an immutable copy of
graph . 
static <N> ImmutableGraph<N> 
copyOf(ImmutableGraph<N> graph)
Deprecated.
no need to use this

int 
degree(N node)
Returns the count of
node 's incident edges, counting selfloops twice (equivalently,
the number of times an edge touches node ). 
protected com.google.common.graph.BaseGraph<N> 
delegate() 
protected long 
edgeCount()
Defer to
AbstractBaseGraph.edges() (based on successors(Object) ) for full edges()
implementation. 
Set<EndpointPair<N>> 
edges()

boolean 
hasEdgeConnecting(EndpointPair<N> endpoints)
Returns true if there is an edge that directly connects
endpoints (in the order, if
any, specified by endpoints ). 
boolean 
hasEdgeConnecting(N nodeU,
N nodeV)
Returns true if there is an edge that directly connects
nodeU to nodeV . 
Set<EndpointPair<N>> 
incidentEdges(N node)
Returns the edges in this graph whose endpoints include
node . 
int 
inDegree(N node)
Returns the count of
node 's incoming edges (equal to predecessors(node).size() )
in a directed graph. 
boolean 
isDirected()
Returns true if the edges in this graph are directed.

protected boolean 
isOrderingCompatible(EndpointPair<?> endpoints) 
ElementOrder<N> 
nodeOrder()
Returns the order of iteration for the elements of
Graph.nodes() . 
Set<N> 
nodes()
Returns all nodes in this graph, in the order specified by
Graph.nodeOrder() . 
int 
outDegree(N node)
Returns the count of
node 's outgoing edges (equal to successors(node).size() )
in a directed graph. 
Set<N> 
predecessors(N node)
Returns all nodes in this graph adjacent to
node which can be reached by traversing
node 's incoming edges against the direction (if any) of the edge. 
Set<N> 
successors(N node)
Returns all nodes in this graph adjacent to
node which can be reached by traversing
node 's outgoing edges in the direction (if any) of the edge. 
protected void 
validateEndpoints(EndpointPair<?> endpoints)
Throws
IllegalArgumentException if the ordering of endpoints is not compatible
with the directionality of this graph. 
equals, hashCode, toString
public static <N> ImmutableGraph<N> copyOf(Graph<N> graph)
graph
.@Deprecated public static <N> ImmutableGraph<N> copyOf(ImmutableGraph<N> graph)
public Set<N> nodes()
Graph
Graph.nodeOrder()
.protected long edgeCount()
AbstractBaseGraph.edges()
(based on successors(Object)
) for full edges()
implementation.public boolean isDirected()
Graph
source node
to a target node
, while
undirected edges connect a pair of nodes to each other.public boolean allowsSelfLoops()
Graph
IllegalArgumentException
.public ElementOrder<N> nodeOrder()
Graph
Graph.nodes()
.public Set<N> adjacentNodes(N node)
Graph
node
in this graph.
This is equal to the union of Graph.predecessors(Object)
and Graph.successors(Object)
.
public Set<N> predecessors(N node)
Graph
node
which can be reached by traversing
node
's incoming edges against the direction (if any) of the edge.
In an undirected graph, this is equivalent to Graph.adjacentNodes(Object)
.
public Set<N> successors(N node)
Graph
node
which can be reached by traversing
node
's outgoing edges in the direction (if any) of the edge.
In an undirected graph, this is equivalent to Graph.adjacentNodes(Object)
.
This is not the same as "all nodes reachable from node
by following outgoing
edges". For that functionality, see Graphs.reachableNodes(Graph, Object)
.
public Set<EndpointPair<N>> incidentEdges(N node)
node
.
This is equal to the union of incoming and outgoing edges.
incidentEdges
in interface Graph<N>
public int degree(N node)
node
's incident edges, counting selfloops twice (equivalently,
the number of times an edge touches node
).
For directed graphs, this is equal to inDegree(node) + outDegree(node)
.
For undirected graphs, this is equal to incidentEdges(node).size()
+ (number of
selfloops incident to node
).
If the count is greater than Integer.MAX_VALUE
, returns Integer.MAX_VALUE
.
public int inDegree(N node)
node
's incoming edges (equal to predecessors(node).size()
)
in a directed graph. In an undirected graph, returns the degree(Object)
.
If the count is greater than Integer.MAX_VALUE
, returns Integer.MAX_VALUE
.
public int outDegree(N node)
node
's outgoing edges (equal to successors(node).size()
)
in a directed graph. In an undirected graph, returns the degree(Object)
.
If the count is greater than Integer.MAX_VALUE
, returns Integer.MAX_VALUE
.
public boolean hasEdgeConnecting(N nodeU, N nodeV)
nodeU
to nodeV
. This is
equivalent to nodes().contains(nodeU) && successors(nodeU).contains(nodeV)
.
In an undirected graph, this is equal to hasEdgeConnecting(nodeV, nodeU)
.
hasEdgeConnecting
in interface Graph<N>
public boolean hasEdgeConnecting(EndpointPair<N> endpoints)
endpoints
(in the order, if
any, specified by endpoints
). This is equivalent to edges().contains(endpoints)
.
Unlike the other EndpointPair
accepting methods, this method does not throw if the
endpoints are unordered; it simply returns false. This is for consistency with the behavior of
Collection#contains(Object)
(which does not generally throw if the object cannot be
present in the collection), and the desire to have this method's behavior be compatible with
edges().contains(endpoints)
.
hasEdgeConnecting
in interface Graph<N>
public Set<EndpointPair<N>> edges()
protected final void validateEndpoints(EndpointPair<?> endpoints)
IllegalArgumentException
if the ordering of endpoints
is not compatible
with the directionality of this graph.protected final boolean isOrderingCompatible(EndpointPair<?> endpoints)
Copyright © 2010–2019. All rights reserved.