/** 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 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 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(); } }
@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(); }
@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(); }
/** 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 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(); } }
@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 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(); }
@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(); }
@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(); }