public Nodes dual() {
Graph graph = belongsTo();
Nodes vertices = graph.nodes(Node.Duality.hvert);
Nodes edges = graph.nodes(Node.Duality.hedge);
return (this == vertices) ? edges : (this == edges) ? vertices : this;
}
public Node.Duality duality() {
Graph graph = belongsTo();
Nodes vertices = graph.nodes(Node.Duality.hvert);
Nodes edges = graph.nodes(Node.Duality.hedge);
return (this == vertices)
? Node.Duality.hvert
: (this == edges) ? Node.Duality.hedge : Node.Duality.hvert;
}
static GraphDescription create(Graph graph) {
if (graph == null) {
return EMPTY;
}
Map<String, NODE> nodes = new HashMap<String, NODE>();
for (NODE node : graph.nodes()) {
if (nodes.put(defined(node.name()), node) != null) {
throw new IllegalArgumentException("Node \"" + node.name() + "\" defined more than once");
}
}
Map<String, REL> rels = new HashMap<String, REL>();
List<REL> relationships = new ArrayList<REL>();
for (REL rel : graph.relationships()) {
createIfAbsent(nodes, rel.start());
createIfAbsent(nodes, rel.end());
String name = rel.name();
if (!name.equals("")) {
if (rels.put(name, rel) != null) {
throw new IllegalArgumentException(
"Relationship \"" + name + "\" defined more than once");
}
}
relationships.add(rel);
}
parse(graph.value(), nodes, relationships);
return new GraphDescription(
nodes.values().toArray(NO_NODES),
relationships.toArray(NO_RELS),
graph.autoIndexNodes(),
graph.autoIndexRelationships());
}
public static String format(Graph graph) {
Map<String, Object> map = new HashMap<String, Object>();
map.put("type", graph.type());
map.put("label", graph.label());
map.put("families", graph.factory().families().toArray());
if (graph.factory().contains(GraphFactory.Family.dual)) {
map.put("nodes:hvert", graph.nodes(Node.Duality.hvert));
map.put("hedge:hedge", graph.nodes(Node.Duality.hedge));
} else {
map.put("nodes", graph.nodes());
}
if (graph.factory().contains(GraphFactory.Family.fractal)) {
map.put("up", graph.up());
}
return format(map);
}
private Graph makeGraph(
int nodeCount, double edgeDensityLower, double edgeDensityUpper, String label) {
this.nodeCount = nodeCount;
this.label = label;
random = new Random(0);
nodes = initializeNodes();
populateNeighbors(edgeDensityLower, edgeDensityUpper);
Graph graph = new Graph();
graph.nodes = Sets.newHashSet(nodes);
graph.label = label;
return graph;
}
@After
public void validateGraphState() {
new EqualsTester()
.addEqualityGroup(network, Graphs.copyOf(network), ImmutableNetwork.copyOf(network))
.testEquals();
String networkString = network.toString();
assertThat(networkString).contains("isDirected: " + network.isDirected());
assertThat(networkString).contains("allowsParallelEdges: " + network.allowsParallelEdges());
assertThat(networkString).contains("allowsSelfLoops: " + network.allowsSelfLoops());
int nodeStart = networkString.indexOf("nodes:");
int edgeStart = networkString.indexOf("edges:");
String nodeString = networkString.substring(nodeStart, edgeStart);
String edgeString = networkString.substring(edgeStart);
Graph<Integer> asGraph = network.asGraph();
assertThat(network.nodes()).isEqualTo(asGraph.nodes());
assertThat(network.nodeOrder()).isEqualTo(asGraph.nodeOrder());
assertThat(network.isDirected()).isEqualTo(asGraph.isDirected());
assertThat(network.allowsSelfLoops()).isEqualTo(asGraph.allowsSelfLoops());
for (String edge : network.edges()) {
// TODO(b/27817069): Consider verifying the edge's incident nodes in the string.
assertThat(edgeString).contains(edge);
Iterator<Integer> endpointsIterator = network.incidentNodes(edge).iterator();
Integer nodeA = endpointsIterator.next();
Integer nodeB = endpointsIterator.next();
assertThat(network.edgesConnecting(nodeA, nodeB)).contains(edge);
assertThat(network.successors(nodeA)).contains(nodeB);
assertThat(network.adjacentNodes(nodeA)).contains(nodeB);
assertThat(network.outEdges(nodeA)).contains(edge);
assertThat(network.incidentEdges(nodeA)).contains(edge);
assertThat(network.predecessors(nodeB)).contains(nodeA);
assertThat(network.adjacentNodes(nodeB)).contains(nodeA);
assertThat(network.inEdges(nodeB)).contains(edge);
assertThat(network.incidentEdges(nodeB)).contains(edge);
for (Integer incidentNode : network.incidentNodes(edge)) {
assertThat(network.nodes()).contains(incidentNode);
for (String adjacentEdge : network.incidentEdges(incidentNode)) {
assertTrue(
edge.equals(adjacentEdge) || network.adjacentEdges(edge).contains(adjacentEdge));
}
}
}
for (Integer node : network.nodes()) {
assertThat(nodeString).contains(node.toString());
assertThat(network.adjacentNodes(node)).isEqualTo(asGraph.adjacentNodes(node));
assertThat(network.predecessors(node)).isEqualTo(asGraph.predecessors(node));
assertThat(network.successors(node)).isEqualTo(asGraph.successors(node));
for (Integer otherNode : network.nodes()) {
Set<String> edgesConnecting = network.edgesConnecting(node, otherNode);
boolean isSelfLoop = node.equals(otherNode);
if (network.isDirected() || !isSelfLoop) {
assertThat(edgesConnecting)
.isEqualTo(Sets.intersection(network.outEdges(node), network.inEdges(otherNode)));
}
if (!network.allowsParallelEdges()) {
assertThat(edgesConnecting.size()).isAtMost(1);
}
if (!network.allowsSelfLoops() && isSelfLoop) {
assertThat(edgesConnecting).isEmpty();
}
for (String edge : edgesConnecting) {
assertThat(network.incidentNodes(edge)).isEqualTo(Endpoints.of(network, node, otherNode));
}
}
for (String incidentEdge : network.incidentEdges(node)) {
assertTrue(
network.inEdges(node).contains(incidentEdge)
|| network.outEdges(node).contains(incidentEdge));
assertThat(network.edges()).contains(incidentEdge);
assertThat(network.incidentNodes(incidentEdge)).contains(node);
}
for (String inEdge : network.inEdges(node)) {
assertThat(network.incidentEdges(node)).contains(inEdge);
assertThat(network.outEdges(network.incidentNodes(inEdge).adjacentNode(node)))
.contains(inEdge);
}
for (String outEdge : network.outEdges(node)) {
assertThat(network.incidentEdges(node)).contains(outEdge);
assertThat(network.inEdges(network.incidentNodes(outEdge).adjacentNode(node)))
.contains(outEdge);
}
for (Integer adjacentNode : network.adjacentNodes(node)) {
assertTrue(
network.predecessors(node).contains(adjacentNode)
|| network.successors(node).contains(adjacentNode));
assertTrue(
!network.edgesConnecting(node, adjacentNode).isEmpty()
|| !network.edgesConnecting(adjacentNode, node).isEmpty());
}
for (Integer predecessor : network.predecessors(node)) {
assertThat(network.successors(predecessor)).contains(node);
assertThat(network.edgesConnecting(predecessor, node)).isNotEmpty();
}
for (Integer successor : network.successors(node)) {
assertThat(network.predecessors(successor)).contains(node);
assertThat(network.edgesConnecting(node, successor)).isNotEmpty();
}
}
}
