@Override protected List<String> create(String[] elements) { ImmutableSortedMap.Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); for (int i = 0; i < elements.length; i++) { builder.put(elements[i], i); } return builder.build().keySet().asList(); }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements).reverse(); return ImmutableSortedSet.orderedBy(comparator) .add(elements) .build() .descendingSet() .asList(); } }
@Override protected List<String> create(String[] elements) { Set<String> set = Sets.newHashSet(); ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder(); for (String s : elements) { checkArgument(set.add(s)); builder.addCopies(s, 2); } return builder.build().elementSet().asList(); }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements); ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator); builder.add(BEFORE_FIRST); builder.add(elements); builder.add(AFTER_LAST); return builder.build().asList().subList(1, elements.length + 1); } }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements); ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator); builder.add(BEFORE_FIRST); builder.add(elements); builder.add(AFTER_LAST); return builder.build().subSet(BEFORE_FIRST_2, AFTER_LAST).asList(); } }
public void testToImmutableSortedSet_customComparator() { Collector<String, ?, ImmutableSortedSet<String>> collector = ImmutableSortedSet.toImmutableSortedSet(String.CASE_INSENSITIVE_ORDER); BiPredicate<ImmutableSortedSet<String>, ImmutableSortedSet<String>> equivalence = (set1, set2) -> set1.equals(set2) && set1.asList().equals(set2.asList()) && set1.comparator().equals(set2.comparator()); ImmutableSortedSet<String> expected = ImmutableSortedSet.orderedBy(String.CASE_INSENSITIVE_ORDER).add("a", "B", "c", "d").build(); CollectorTester.of(collector, equivalence) .expectCollects(expected, "a", "B", "a", "c", "b", "b", "d"); }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements); ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator); builder.add(BEFORE_FIRST); builder.add(BEFORE_FIRST_2); builder.add(elements); builder.add(AFTER_LAST); builder.add(AFTER_LAST_2); return builder .build() .subSet(BEFORE_FIRST_2, AFTER_LAST_2) .asList() .subList(1, elements.length + 1); } }
/** * For a given collection of paths returns the order of traversal of their hierarchy tree. * * <p>The returned order assumes the path walk starts at the root and will also return non-leaf * path nodes of the given paths. The order of traversal is lexicographical and is stable. */ public static List<ZipPath> toPathWalkingOrder(Collection<ZipPath> paths) { ImmutableSortedSet.Builder<ZipPath> walkOrderedSet = ImmutableSortedSet.naturalOrder(); for (ZipPath path : paths) { for (int i = 0; i < path.getNameCount(); i++) { walkOrderedSet.add(path.subpath(0, i + 1)); } } return walkOrderedSet.build().asList(); }
private List<String> toTaskPaths(Set<Task> tasks) { return ImmutableSortedSet.copyOf(Collections2.transform(tasks, new Function<Task, String>() { @Override public String apply(Task task) { return task.getPath(); } })).asList(); } });
@Nullable @Override public List<String> getOutputPropertyNames() { // Copy should be a NOOP as this is an immutable sorted set upstream. ImmutableSortedSet<String> outputPropertyNames = key.getInputs().getOutputPropertyNames(); if (outputPropertyNames == null || outputPropertyNames.isEmpty()) { return null; } else { return ImmutableSortedSet.copyOf(outputPropertyNames).asList(); } }
private Layout getLayout() { long epoch = 0; UUID clusterId = UUID.randomUUID(); List<String> servers = getClusterLayoutServers().asList(); LayoutSegment segment = new LayoutSegment( Layout.ReplicationMode.CHAIN_REPLICATION, 0L, -1L, Collections.singletonList(new Layout.LayoutStripe(servers)) ); return new Layout(servers, servers, Collections.singletonList(segment), epoch, clusterId); } }
/** Returns list of enum file elements, sorted alphabetically by name. */ private List<GrpcElementDocView> generateEnumFileElements( ModelTypeTable typeTable, SurfaceNamer namer, List<ProtoFile> containerElements) { ImmutableSortedSet.Builder<GrpcElementDocView> elements = ImmutableSortedSet.orderedBy(Comparator.comparing(GrpcElementDocView::name)); for (ProtoContainerElement containerElement : containerElements) { elements.addAll(generateEnumFileElements(typeTable, namer, containerElement)); } return elements.build().asList(); }
@Override protected List<String> create(String[] elements) { ImmutableSortedMap.Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); for (int i = 0; i < elements.length; i++) { builder.put(elements[i], i); } return builder.build().keySet().asList(); }
@Override protected List<String> create(String[] elements) { ImmutableSortedMap.Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); for (int i = 0; i < elements.length; i++) { builder.put(elements[i], i); } return builder.build().keySet().asList(); }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements).reverse(); return ImmutableSortedSet.orderedBy(comparator) .add(elements) .build() .descendingSet() .asList(); } }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements).reverse(); return ImmutableSortedSet .orderedBy(comparator) .add(elements) .build() .descendingSet() .asList(); } }
@Override protected List<String> create(String[] elements) { Set<String> set = Sets.newHashSet(); ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder(); for (String s : elements) { checkArgument(set.add(s)); builder.addCopies(s, 2); } return builder.build().elementSet().asList(); }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements); ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator); builder.add(BEFORE_FIRST); builder.add(elements); builder.add(AFTER_LAST); return builder.build().subSet(BEFORE_FIRST_2, AFTER_LAST).asList(); } }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements); ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator); builder.add(BEFORE_FIRST); builder.add(elements); builder.add(AFTER_LAST); return builder.build().asList().subList(1, elements.length + 1); } }