/** Returns an empty mutable map whose keys will respect this {@link ElementOrder}. */ <K extends T, V> Map<K, V> createMap(int expectedSize) { switch (type) { case UNORDERED: return Maps.newHashMapWithExpectedSize(expectedSize); case INSERTION: return Maps.newLinkedHashMapWithExpectedSize(expectedSize); case SORTED: return Maps.newTreeMap(comparator()); default: throw new AssertionError(); } }
/** * Returns an instance which specifies that the ordering of the elements is guaranteed to be * determined by {@code comparator}. */ public static <S> ElementOrder<S> sorted(Comparator<S> comparator) { return new ElementOrder<S>(Type.SORTED, comparator); }
/** * Constructs a graph with the properties specified in {@code builder}, initialized with the given * node and edge maps. */ ConfigurableNetwork( NetworkBuilder<? super N, ? super E> builder, Map<N, NetworkConnections<N, E>> nodeConnections, Map<E, N> edgeToReferenceNode) { this.isDirected = builder.directed; this.allowsParallelEdges = builder.allowsParallelEdges; this.allowsSelfLoops = builder.allowsSelfLoops; this.nodeOrder = builder.nodeOrder.cast(); this.edgeOrder = builder.edgeOrder.cast(); // Prefer the heavier "MapRetrievalCache" for nodes if lookup is expensive. This optimizes // methods that access the same node(s) repeatedly, such as Graphs.removeEdgesConnecting(). this.nodeConnections = (nodeConnections instanceof TreeMap) ? new MapRetrievalCache<N, NetworkConnections<N, E>>(nodeConnections) : new MapIteratorCache<N, NetworkConnections<N, E>>(nodeConnections); this.edgeToReferenceNode = new MapIteratorCache<>(edgeToReferenceNode); }
@Test public void customComparable() { MutableGraph<ComparableSubClass> graph = GraphBuilder.undirected().nodeOrder(ElementOrder.<ComparableSubClass>natural()).build(); ComparableSubClass node2 = new ComparableSubClass(2); ComparableSubClass node4 = new ComparableSubClass(4); ComparableSubClass node6 = new ComparableSubClass(6); ComparableSubClass node8 = new ComparableSubClass(8); graph.addNode(node4); graph.addNode(node2); graph.addNode(node6); graph.addNode(node8); assertThat(graph.nodeOrder().comparator()).isEqualTo(Ordering.natural()); assertThat(graph.nodes()).containsExactly(node2, node4, node6, node8).inOrder(); }
/** Constructs a graph with the properties specified in {@code builder}. */ ConfigurableValueGraph(AbstractGraphBuilder<? super N> builder) { this( builder, builder.nodeOrder.<N, GraphConnections<N, V>>createMap( builder.expectedNodeCount.or(DEFAULT_NODE_COUNT)), 0L); }
@Test public void customComparator() { Comparator<NonComparableSuperClass> comparator = new Comparator<NonComparableSuperClass>() { @Override public int compare(NonComparableSuperClass left, NonComparableSuperClass right) { return left.value.compareTo(right.value); } }; MutableGraph<NonComparableSuperClass> graph = GraphBuilder.undirected().nodeOrder(ElementOrder.sorted(comparator)).build(); NonComparableSuperClass node1 = new NonComparableSuperClass(1); NonComparableSuperClass node3 = new NonComparableSuperClass(3); NonComparableSuperClass node5 = new NonComparableSuperClass(5); NonComparableSuperClass node7 = new NonComparableSuperClass(7); graph.addNode(node1); graph.addNode(node7); graph.addNode(node5); graph.addNode(node3); assertThat(graph.nodeOrder().comparator()).isEqualTo(comparator); assertThat(graph.nodes()).containsExactly(node1, node3, node5, node7).inOrder(); }
public Set<EntityDescriptor> resolveEntities(Collection<EntityDescriptor> unresolvedEntities) { final MutableGraph<EntityDescriptor> dependencyGraph = GraphBuilder.directed() .allowsSelfLoops(false) .nodeOrder(ElementOrder.insertion()) .build(); unresolvedEntities.forEach(dependencyGraph::addNode); final HashSet<EntityDescriptor> resolvedEntities = new HashSet<>(); final MutableGraph<EntityDescriptor> finalDependencyGraph = resolveDependencyGraph(dependencyGraph, resolvedEntities); LOG.debug("Final dependency graph: {}", finalDependencyGraph); return finalDependencyGraph.nodes(); }
@Test public void edgeOrder_natural() { MutableNetwork<Integer, String> network = NetworkBuilder.directed().edgeOrder(ElementOrder.<String>natural()).build(); addEdges(network); assertThat(network.edgeOrder()).isEqualTo(ElementOrder.sorted(Ordering.<String>natural())); assertThat(network.edges()).containsExactly("e", "i", "p").inOrder(); assertThat(network.nodeOrder()).isEqualTo(insertion()); // default }
@Test public void nodeOrder_natural() { MutableGraph<Integer> graph = GraphBuilder.directed().nodeOrder(ElementOrder.<Integer>natural()).build(); addNodes(graph); assertThat(graph.nodeOrder()).isEqualTo(ElementOrder.sorted(Ordering.<Integer>natural())); assertThat(graph.nodes()).containsExactly(1, 3, 4).inOrder(); }
@Test public void edgeOrder_sorted() { MutableNetwork<Integer, String> network = NetworkBuilder.directed() .edgeOrder(ElementOrder.sorted(Ordering.<String>natural().reverse())) .build(); addEdges(network); assertThat(network.edgeOrder()) .isEqualTo(ElementOrder.sorted(Ordering.<String>natural().reverse())); assertThat(network.edges()).containsExactly("p", "i", "e").inOrder(); assertThat(network.nodeOrder()).isEqualTo(ElementOrder.insertion()); // default }
@Test public void nodeOrderUnorderedandEdgesSorted() { MutableNetwork<Integer, String> network = NetworkBuilder.directed() .nodeOrder(unordered()) .edgeOrder(ElementOrder.sorted(Ordering.<String>natural().reverse())) .build(); addEdges(network); assertThat(network.edgeOrder()) .isEqualTo(ElementOrder.sorted(Ordering.<String>natural().reverse())); assertThat(network.edges()).containsExactly("p", "i", "e").inOrder(); assertThat(network.nodeOrder()).isEqualTo(unordered()); assertThat(network.nodes()).containsExactly(4, 1, 3); }
/** @return the graph for this demo */ Network<String, Number> getGraph() { Graph<String> g = new EppsteinPowerLawGenerator<>(new NodeFactory(), 26, 50, 50).get(); // convert this graph into a Network because the visualization system can't handle Graphs (yet) MutableNetwork<String, Number> graph = NetworkBuilder.undirected().nodeOrder(ElementOrder.<String>natural()).build(); EdgeFactory edgeFactory = new EdgeFactory(); // this implicitly removes any isolated nodes, as intended for (EndpointPair<String> endpoints : g.edges()) { graph.addEdge(endpoints.nodeU(), endpoints.nodeV(), edgeFactory.get()); } return graph; }
@Test public void nodeOrder_sorted() { MutableGraph<Integer> graph = GraphBuilder.directed() .nodeOrder(ElementOrder.sorted(Ordering.<Integer>natural().reverse())) .build(); addNodes(graph); assertThat(graph.nodeOrder()) .isEqualTo(ElementOrder.sorted(Ordering.<Integer>natural().reverse())); assertThat(graph.nodes()).containsExactly(4, 3, 1).inOrder(); }
@Test public void customComparable() { MutableCTree<ComparableSubClass> tree = TreeBuilder.builder().nodeOrder(ElementOrder.<ComparableSubClass>natural()).build(); ComparableSubClass node2 = new ComparableSubClass(2); ComparableSubClass node4 = new ComparableSubClass(4); ComparableSubClass node6 = new ComparableSubClass(6); ComparableSubClass node8 = new ComparableSubClass(8); tree.putEdge(node2, node8); tree.putEdge(node2, node6); tree.putEdge(node6, node4); assertThat(tree.nodeOrder().comparator()).isEqualTo(Ordering.natural()); assertThat(tree.nodes()).containsExactly(node2, node4, node6, node8).inOrder(); }
/** Constructs a graph with the properties specified in {@code builder}. */ ConfigurableNetwork(NetworkBuilder<? super N, ? super E> builder) { this( builder, builder.nodeOrder.<N, NetworkConnections<N, E>>createMap( builder.expectedNodeCount.or(DEFAULT_NODE_COUNT)), builder.edgeOrder.<E, N>createMap(builder.expectedEdgeCount.or(DEFAULT_EDGE_COUNT))); }
@Test public void customComparator() { Comparator<NonComparableSuperClass> comparator = comparing(left -> left.value); MutableCTree<NonComparableSuperClass> tree = TreeBuilder.builder().nodeOrder(ElementOrder.sorted(comparator)).build(); NonComparableSuperClass node1 = new NonComparableSuperClass(1); NonComparableSuperClass node3 = new NonComparableSuperClass(3); NonComparableSuperClass node5 = new NonComparableSuperClass(5); NonComparableSuperClass node7 = new NonComparableSuperClass(7); tree.putEdge(node1, node7); tree.putEdge(node1, node5); tree.putEdge(node5, node3); assertThat(tree.nodeOrder().comparator()).isEqualTo(comparator); assertThat(tree.nodes()).containsExactly(node1, node3, node5, node7).inOrder(); }
@Test public void edgeOrder_insertion() { MutableNetwork<Integer, String> network = NetworkBuilder.directed().edgeOrder(insertion()).build(); addEdges(network); assertThat(network.edgeOrder()).isEqualTo(ElementOrder.insertion()); assertThat(network.edges()).containsExactly("i", "e", "p").inOrder(); assertThat(network.nodeOrder()).isEqualTo(ElementOrder.insertion()); // default }
@Test public void edgeOrder_natural() { MutableNetwork<Integer, String> network = NetworkBuilder.directed().edgeOrder(ElementOrder.<String>natural()).build(); addEdges(network); assertThat(network.edgeOrder()).isEqualTo(ElementOrder.sorted(Ordering.<String>natural())); assertThat(network.edges()).containsExactly("e", "i", "p").inOrder(); assertThat(network.nodeOrder()).isEqualTo(insertion()); // default }