@Override public MutableNetwork<Integer, String> createGraph() { return NetworkBuilder.undirected().allowsParallelEdges(true).allowsSelfLoops(true).build(); }
@Override public MutableNetwork<Integer, String> createGraph() { return NetworkBuilder.undirected().allowsParallelEdges(false).allowsSelfLoops(false).build(); }
@Override public MutableNetwork<Integer, String> createGraph() { return NetworkBuilder.directed().allowsParallelEdges(true).allowsSelfLoops(true).build(); }
@Override public MutableNetwork<Integer, String> createGraph() { return NetworkBuilder.directed().allowsParallelEdges(false).allowsSelfLoops(false).build(); }
@Test public void createDirected_multigraph() { MutableNetwork<Integer, String> directedMultigraph = NetworkBuilder.directed().allowsParallelEdges(true).build(); assertThat(directedMultigraph.addEdge(N1, N2, E12)).isTrue(); assertThat(directedMultigraph.addEdge(N1, N2, E12_A)).isTrue(); assertThat(directedMultigraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12, E12_A)); assertThat(directedMultigraph.edgesConnecting(N2, N1)).isEmpty(); }
@Test public void createUndirected_multigraph() { MutableNetwork<Integer, String> undirectedMultigraph = NetworkBuilder.undirected().allowsParallelEdges(true).build(); assertThat(undirectedMultigraph.addEdge(N1, N2, E12)).isTrue(); assertThat(undirectedMultigraph.addEdge(N1, N2, E12_A)).isTrue(); assertThat(undirectedMultigraph.addEdge(N2, N1, E21)).isTrue(); assertThat(undirectedMultigraph.edgesConnecting(N1, N2)) .isEqualTo(ImmutableSet.of(E12, E12_A, E21)); }
/** * Returns a {@link NetworkBuilder} initialized with all properties queryable from {@code * network}. * * <p>The "queryable" properties are those that are exposed through the {@link Network} interface, * such as {@link Network#isDirected()}. Other properties, such as {@link * #expectedNodeCount(int)}, are not set in the new builder. */ public static <N, E> NetworkBuilder<N, E> from(Network<N, E> network) { return new NetworkBuilder<N, E>(network.isDirected()) .allowsParallelEdges(network.allowsParallelEdges()) .allowsSelfLoops(network.allowsSelfLoops()) .nodeOrder(network.nodeOrder()) .edgeOrder(network.edgeOrder()); }
@Before public void init() { MutableGraph<Integer> mutableDirectedGraph = GraphBuilder.directed().allowsSelfLoops(true).build(); MutableGraph<Integer> mutableUndirectedGraph = GraphBuilder.undirected().allowsSelfLoops(true).build(); graphsToTest = ImmutableList.of(mutableDirectedGraph, mutableUndirectedGraph); directedGraph = mutableDirectedGraph; undirectedGraph = mutableUndirectedGraph; MutableNetwork<Integer, String> mutableDirectedNetwork = NetworkBuilder.directed().allowsParallelEdges(true).allowsSelfLoops(true).build(); MutableNetwork<Integer, String> mutableUndirectedNetwork = NetworkBuilder.undirected().allowsParallelEdges(true).allowsSelfLoops(true).build(); networksToTest = ImmutableList.of(mutableDirectedNetwork, mutableUndirectedNetwork); directedNetwork = mutableDirectedNetwork; undirectedNetwork = mutableUndirectedNetwork; }
@Before public void setUp() throws Exception { NetworkBuilder<Object, Object> builder = (edgeType == EdgeType.DIRECTED) ? NetworkBuilder.directed() : NetworkBuilder.undirected(); network = builder.allowsSelfLoops(true).allowsParallelEdges(true).build(); networkForTest = NetworkForTest.from(network); }
@Test public void equivalent_propertiesDiffer() { network.addEdge(N1, N2, E12); MutableNetwork<Integer, String> g2 = NetworkBuilder.from(network) .allowsParallelEdges(!network.allowsParallelEdges()) .allowsSelfLoops(!network.allowsSelfLoops()) .build(); g2.addEdge(N1, N2, E12); assertThat(network).isEqualTo(g2); }
@Test public void equivalent_edgeAddOrdersDiffer() { NetworkBuilder<Integer, String> builder = NetworkBuilder.from(network).allowsParallelEdges(true); MutableNetwork<Integer, String> g1 = builder.build(); MutableNetwork<Integer, String> g2 = builder.build(); // for ug1, add e12 first, then e12_a g1.addEdge(N1, N2, E12); g1.addEdge(N1, N2, E12_A); // for ug2, add e12_a first, then e12 g2.addEdge(N1, N2, E12_A); g2.addEdge(N1, N2, E12); assertThat(g1).isEqualTo(g2); }
/** * Returns a {@link NetworkBuilder} initialized with all properties queryable from {@code * network}. * * <p>The "queryable" properties are those that are exposed through the {@link Network} interface, * such as {@link Network#isDirected()}. Other properties, such as {@link * #expectedNodeCount(int)}, are not set in the new builder. */ public static <N, E> NetworkBuilder<N, E> from(Network<N, E> network) { return new NetworkBuilder<N, E>(network.isDirected()) .allowsParallelEdges(network.allowsParallelEdges()) .allowsSelfLoops(network.allowsSelfLoops()) .nodeOrder(network.nodeOrder()) .edgeOrder(network.edgeOrder()); }
networkBuilder.allowsParallelEdges(true).allowsSelfLoops(true).build();
private static MutableNetwork<Integer, String> buildUndirectedNetwork() { MutableNetwork<Integer, String> undirectedGraph = NetworkBuilder.undirected().allowsParallelEdges(true).allowsSelfLoops(true).build(); undirectedGraph.addEdge(N1, N1, E11); undirectedGraph.addEdge(N1, N2, E12); undirectedGraph.addEdge(N1, N1, E11_A); undirectedGraph.addEdge(N1, N2, E12_A); undirectedGraph.addEdge(N2, N1, E21); return undirectedGraph; } }
private static MutableNetwork<Integer, String> buildDirectedNetwork() { MutableNetwork<Integer, String> directedGraph = NetworkBuilder.directed().allowsParallelEdges(true).allowsSelfLoops(true).build(); directedGraph.addEdge(N1, N1, E11); directedGraph.addEdge(N1, N2, E12); directedGraph.addEdge(N1, N1, E11_A); directedGraph.addEdge(N1, N2, E12_A); directedGraph.addEdge(N2, N1, E21); return directedGraph; }
/** * Returns a {@link NetworkBuilder} initialized with all properties queryable from {@code * network}. * * <p>The "queryable" properties are those that are exposed through the {@link Network} interface, * such as {@link Network#isDirected()}. Other properties, such as {@link * #expectedNodeCount(int)}, are not set in the new builder. */ public static <N, E> NetworkBuilder<N, E> from(Network<N, E> network) { return new NetworkBuilder<N, E>(network.isDirected()) .allowsParallelEdges(network.allowsParallelEdges()) .allowsSelfLoops(network.allowsSelfLoops()) .nodeOrder(network.nodeOrder()) .edgeOrder(network.edgeOrder()); }
@Test public void transpose_directedNetwork() { MutableNetwork<Integer, String> directedGraph = NetworkBuilder.directed().allowsParallelEdges(true).allowsSelfLoops(true).build(); directedGraph.addEdge(N1, N3, E13); directedGraph.addEdge(N3, N1, E31); NetworkBuilder.directed().allowsParallelEdges(true).allowsSelfLoops(true).build(); expectedTranspose.addEdge(N3, N1, E13); expectedTranspose.addEdge(N1, N3, E31);
@Test public void endpointPair_undirectedNetwork() { MutableNetwork<Integer, String> undirectedNetwork = NetworkBuilder.undirected().allowsParallelEdges(true).allowsSelfLoops(true).build(); undirectedNetwork.addNode(N0); undirectedNetwork.addEdge(N1, N2, E12); undirectedNetwork.addEdge(N2, N1, E12_A); // adds parallel edge, won't be in Graph edges undirectedNetwork.addEdge(N1, N3, E13); undirectedNetwork.addEdge(N4, N4, E44); containsExactlySanityCheck( undirectedNetwork.asGraph().edges(), EndpointPair.unordered(N1, N2), EndpointPair.unordered(N1, N3), EndpointPair.unordered(N4, N4)); }
public VxlanTopology(Map<String, Configuration> configurations) { MutableNetwork<VxlanNode, VxlanEdge> graph = NetworkBuilder.directed().allowsParallelEdges(false).allowsSelfLoops(false).build(); Map<Integer, List<Vrf>> vrfsByVni = initVniVrfAssociations(configurations); Map<Vrf, String> vrfHostnames = initVrfHostnameMap(configurations); vrfsByVni.forEach((vni, vrfs) -> addVniEdges(graph, vrfHostnames, vni, vrfs)); _graph = ImmutableNetwork.copyOf(graph); }
private static MutableNetwork<Integer, String> buildDirectedNetwork() { MutableNetwork<Integer, String> directedGraph = NetworkBuilder.directed().allowsParallelEdges(true).allowsSelfLoops(true).build(); directedGraph.addEdge(N1, N1, E11); directedGraph.addEdge(N1, N2, E12); directedGraph.addEdge(N1, N1, E11_A); directedGraph.addEdge(N1, N2, E12_A); directedGraph.addEdge(N2, N1, E21); return directedGraph; }