@Override public boolean contains(@Nullable Object obj) { if (!(obj instanceof EndpointPair)) { return false; } EndpointPair<?> endpointPair = (EndpointPair<?>) obj; if (!endpointPair.isOrdered()) { return false; } Object source = endpointPair.source(); Object target = endpointPair.target(); return (node.equals(source) && graph.successors(node).contains(target)) || (node.equals(target) && graph.predecessors(node).contains(source)); } }
assertThat(graph.successors(predecessor)).contains(node); assertThat(graph.hasEdgeConnecting(predecessor, node)).isTrue(); assertThat(graph.incidentEdges(node)).contains(EndpointPair.of(graph, predecessor, node)); allEndpointPairs.add(EndpointPair.of(graph, node, successor)); assertThat(graph.predecessors(successor)).contains(node); assertThat(graph.hasEdgeConnecting(node, successor)).isTrue(); assertThat(graph.incidentEdges(node)).contains(EndpointPair.of(graph, node, successor)); assertThat(graph.hasEdgeConnecting(endpoints.source(), endpoints.target())).isTrue(); } else { assertThat(graph.hasEdgeConnecting(endpoints.nodeU(), endpoints.nodeV())).isTrue(); assertThat(graph.edges()).doesNotContain(EndpointPair.of(graph, new Object(), new Object())); assertThat(graph.edges()).isEqualTo(allEndpointPairs);
@Test public void testOrderedEndpointPair() { EndpointPair<String> ordered = EndpointPair.ordered("source", "target"); assertThat(ordered.isOrdered()).isTrue(); assertThat(ordered).containsExactly("source", "target").inOrder(); assertThat(ordered.source()).isEqualTo("source"); assertThat(ordered.target()).isEqualTo("target"); assertThat(ordered.nodeU()).isEqualTo("source"); assertThat(ordered.nodeV()).isEqualTo("target"); assertThat(ordered.adjacentNode("source")).isEqualTo("target"); assertThat(ordered.adjacentNode("target")).isEqualTo("source"); assertThat(ordered.toString()).isEqualTo("<source -> target>"); }
@Test public void testUnorderedEndpointPair() { EndpointPair<String> unordered = EndpointPair.unordered("chicken", "egg"); assertThat(unordered.isOrdered()).isFalse(); assertThat(unordered).containsExactly("chicken", "egg"); assertThat(ImmutableSet.of(unordered.nodeU(), unordered.nodeV())) .containsExactly("chicken", "egg"); assertThat(unordered.adjacentNode(unordered.nodeU())).isEqualTo(unordered.nodeV()); assertThat(unordered.adjacentNode(unordered.nodeV())).isEqualTo(unordered.nodeU()); assertThat(unordered.toString()).contains("chicken"); assertThat(unordered.toString()).contains("egg"); }
@Override public boolean contains(@Nullable Object obj) { if (!(obj instanceof EndpointPair)) { return false; } EndpointPair<?> endpointPair = (EndpointPair<?>) obj; if (endpointPair.isOrdered()) { return false; } Set<N> adjacent = graph.adjacentNodes(node); Object nodeU = endpointPair.nodeU(); Object nodeV = endpointPair.nodeV(); return (node.equals(nodeV) && adjacent.contains(nodeU)) || (node.equals(nodeU) && adjacent.contains(nodeV)); } }
@After public void validateSourceAndTarget() { for (Integer node : network.nodes()) { for (String inEdge : network.inEdges(node)) { EndpointPair<Integer> endpointPair = network.incidentNodes(inEdge); assertThat(endpointPair.source()).isEqualTo(endpointPair.adjacentNode(node)); assertThat(endpointPair.target()).isEqualTo(node); } for (String outEdge : network.outEdges(node)) { EndpointPair<Integer> endpointPair = network.incidentNodes(outEdge); assertThat(endpointPair.source()).isEqualTo(node); assertThat(endpointPair.target()).isEqualTo(endpointPair.adjacentNode(node)); } for (Integer adjacentNode : network.adjacentNodes(node)) { Set<String> edges = network.edgesConnecting(node, adjacentNode); Set<String> antiParallelEdges = network.edgesConnecting(adjacentNode, node); assertThat(node.equals(adjacentNode) || Collections.disjoint(edges, antiParallelEdges)) .isTrue(); } } }
@Override public N apply(E edge) { return network.incidentNodes(edge).target(); } };
@Override public EndpointPair<N> apply(N successor) { return EndpointPair.ordered(node, successor); } })));
@Override public N apply(E edge) { return network.incidentNodes(edge).source(); } };
@Override public EndpointPair<N> apply(N adjacentNode) { return EndpointPair.unordered(node, adjacentNode); } }));
@Override public boolean apply(E edge) { return incidentNodes(edge).adjacentNode(nodePresent).equals(nodeToCheck); } };
@Test public void testEquals() { EndpointPair<String> ordered = EndpointPair.ordered("a", "b"); EndpointPair<String> orderedMirror = EndpointPair.ordered("b", "a"); EndpointPair<String> unordered = EndpointPair.unordered("a", "b"); EndpointPair<String> unorderedMirror = EndpointPair.unordered("b", "a"); new EqualsTester() .addEqualityGroup(ordered) .addEqualityGroup(orderedMirror) .addEqualityGroup(unordered, unorderedMirror) .testEquals(); }
@Override public EndpointPair<N> incidentNodes(E edge) { N nodeU = checkedReferenceNode(edge); N nodeV = nodeConnections.get(nodeU).adjacentNode(edge); return EndpointPair.of(this, nodeU, nodeV); }
protected final boolean isOrderingCompatible(EndpointPair<?> endpoints) { return endpoints.isOrdered() || !this.isDirected(); }