@Override public V apply(EndpointPair<N> edge) { return graph.edgeValueOrDefault(edge.nodeU(), edge.nodeV(), null); } };
@Override public boolean hasEdgeConnecting(EndpointPair<N> endpoints) { checkNotNull(endpoints); if (!isOrderingCompatible(endpoints)) { return false; } return !edgesConnecting(endpoints.nodeU(), endpoints.nodeV()).isEmpty(); }
@Override public Set<E> adjacentEdges(E edge) { EndpointPair<N> endpointPair = incidentNodes(edge); // Verifies that edge is in this network. Set<E> endpointPairIncidentEdges = Sets.union(incidentEdges(endpointPair.nodeU()), incidentEdges(endpointPair.nodeV())); return Sets.difference(endpointPairIncidentEdges, ImmutableSet.of(edge)); }
@Override public boolean hasEdgeConnecting(EndpointPair<N> endpoints) { checkNotNull(endpoints); if (!isOrderingCompatible(endpoints)) { return false; } N nodeU = endpoints.nodeU(); N nodeV = endpoints.nodeV(); return nodes().contains(nodeU) && successors(nodeU).contains(nodeV); }
@Override public boolean hasEdgeConnecting(EndpointPair<N> endpoints) { checkNotNull(endpoints); return isOrderingCompatible(endpoints) && hasEdgeConnecting_internal(endpoints.nodeU(), endpoints.nodeV()); }
@Override public Set<E> edgesConnecting(EndpointPair<N> endpoints) { validateEndpoints(endpoints); return edgesConnecting(endpoints.nodeU(), endpoints.nodeV()); }
@Override public boolean putEdge(EndpointPair<N> endpoints) { validateEndpoints(endpoints); return putEdge(endpoints.nodeU(), endpoints.nodeV()); }
@Override public Optional<E> edgeConnecting(EndpointPair<N> endpoints) { validateEndpoints(endpoints); return edgeConnecting(endpoints.nodeU(), endpoints.nodeV()); }
@Override public boolean removeEdge(EndpointPair<N> endpoints) { validateEndpoints(endpoints); return removeEdge(endpoints.nodeU(), endpoints.nodeV()); } }
@SuppressWarnings("unchecked") @Override public boolean contains(@Nullable Object obj) { if (!(obj instanceof EndpointPair)) { return false; } EndpointPair<?> endpointPair = (EndpointPair<?>) obj; return isOrderingCompatible(endpointPair) && nodes().contains(endpointPair.nodeU()) && successors((N) endpointPair.nodeU()).contains(endpointPair.nodeV()); } };
@Override public EndpointPair<N> incidentNodes(E edge) { EndpointPair<N> endpointPair = delegate().incidentNodes(edge); return EndpointPair.of(network, endpointPair.nodeV(), endpointPair.nodeU()); // transpose }
@Override @CanIgnoreReturnValue public V putEdgeValue(EndpointPair<N> endpoints, V value) { validateEndpoints(endpoints); return putEdgeValue(endpoints.nodeU(), endpoints.nodeV(), value); }
@Override @CanIgnoreReturnValue public boolean addEdge(EndpointPair<N> endpoints, E edge) { validateEndpoints(endpoints); return addEdge(endpoints.nodeU(), endpoints.nodeV(), edge); }
@Override public @Nullable E edgeConnectingOrNull(EndpointPair<N> endpoints) { validateEndpoints(endpoints); return edgeConnectingOrNull(endpoints.nodeU(), endpoints.nodeV()); }
@Override public @Nullable V edgeValueOrDefault(EndpointPair<N> endpoints, @Nullable V defaultValue) { validateEndpoints(endpoints); return edgeValueOrDefault_internal(endpoints.nodeU(), endpoints.nodeV(), defaultValue); }
@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"); }
@Test public void testSelfLoop() { EndpointPair<String> unordered = EndpointPair.unordered("node", "node"); assertThat(unordered.isOrdered()).isFalse(); assertThat(unordered).containsExactly("node", "node"); assertThat(unordered.nodeU()).isEqualTo("node"); assertThat(unordered.nodeV()).isEqualTo("node"); assertThat(unordered.adjacentNode("node")).isEqualTo("node"); assertThat(unordered.toString()).isEqualTo("[node, node]"); }
protected boolean addEdge(EndpointPair<Integer> endpoints, String e) { network.addNode(endpoints.nodeU()); network.addNode(endpoints.nodeV()); return network.addEdge(endpoints, e); }
@Test public void incidentNodes_selfLoop() { addEdge(N1, N1, E11); assertThat(network.incidentNodes(E11).nodeU()).isEqualTo(N1); assertThat(network.incidentNodes(E11).nodeV()).isEqualTo(N1); }
@CanIgnoreReturnValue protected boolean putEdge(EndpointPair<Integer> endpoints) { graph.addNode(endpoints.nodeU()); graph.addNode(endpoints.nodeV()); return graph.putEdge(endpoints); }