@Override <E extends Comparable<E>> ImmutableSortedSet.Builder<E> builder() { return ImmutableSortedSet.naturalOrder(); }
public Pipeline() { m_lock = new Object(); m_pipeline = ImmutableSortedSet.<FilterSubscriber>naturalOrder().build(); }
public void testBuilderGenerics_SelfComparable() { // testing simple creation ImmutableSortedSet.Builder<SelfComparableExample> natural = ImmutableSortedSet.naturalOrder(); assertThat(natural).isNotNull(); ImmutableSortedSet.Builder<SelfComparableExample> reverse = ImmutableSortedSet.reverseOrder(); assertThat(reverse).isNotNull(); }
public void testBuilderGenerics_SuperComparable() { // testing simple creation ImmutableSortedSet.Builder<SuperComparableExample> natural = ImmutableSortedSet.naturalOrder(); assertThat(natural).isNotNull(); ImmutableSortedSet.Builder<SuperComparableExample> reverse = ImmutableSortedSet.reverseOrder(); assertThat(reverse).isNotNull(); } }
public void addAll(Collection<FilterSubscriber> subscribers) { synchronized (m_lock) { m_pipeline = ImmutableSortedSet.<FilterSubscriber>naturalOrder() .addAll(m_pipeline) .addAll(subscribers).build(); } }
@Override ImmutableSortedSet<Endpoint> onDnsRecords(List<DnsRecord> records, int ttl) throws Exception { final ImmutableSortedSet.Builder<Endpoint> builder = ImmutableSortedSet.naturalOrder(); for (DnsRecord r : records) { if (!(r instanceof DnsRawRecord) || r.type() != DnsRecordType.TXT) {
public void testLegacyComparable_builder_natural() { @SuppressWarnings("unchecked") // Note: IntelliJ wrongly reports an error for this statement ImmutableSortedSet.Builder<LegacyComparable> builder = ImmutableSortedSet.<LegacyComparable>naturalOrder(); builder.addAll(LegacyComparable.VALUES_BACKWARD); builder.add(LegacyComparable.X); builder.add(LegacyComparable.Y, LegacyComparable.Z); ImmutableSortedSet<LegacyComparable> set = builder.build(); assertTrue(Iterables.elementsEqual(LegacyComparable.VALUES_FORWARD, set)); }
@Override ImmutableSortedSet<Endpoint> onDnsRecords(List<DnsRecord> records, int ttl) throws Exception { final ImmutableSortedSet.Builder<Endpoint> builder = ImmutableSortedSet.naturalOrder(); for (DnsRecord r : records) { if (!(r instanceof DnsRawRecord) || r.type() != DnsRecordType.SRV) {
@Override ImmutableSortedSet<Endpoint> onDnsRecords(List<DnsRecord> records, int ttl) throws Exception { final ImmutableSortedSet.Builder<Endpoint> builder = ImmutableSortedSet.naturalOrder(); final boolean hasLoopbackARecords = records.stream()
ImmutableSortedSet.Builder<Import> imports = ImmutableSortedSet.naturalOrder();
@SuppressWarnings("unchecked") @Override protected Builder<Object> createBuilder() { /* Not quite sure what to do with sorting/ordering; may require better support either * via annotations, or via custom serialization (bean style that includes ordering * aspects) */ @SuppressWarnings("rawtypes") ImmutableSortedSet.Builder<?> builderComp = ImmutableSortedSet.<Comparable> naturalOrder(); ImmutableSortedSet.Builder<Object> builder = (ImmutableSortedSet.Builder<Object>) builderComp; return builder; } }
private SortedSet<String> importsSortedByFullName() { ImmutableSortedSet.Builder<String> sortedImports = ImmutableSortedSet.naturalOrder(); for (Class<?> clazz : imports) { sortedImports.add(clazz.getCanonicalName()); } return sortedImports.build(); }
private SortedSet<String> importsSortedBySimpleName() { ImmutableSortedSet.Builder<String> sortedImports = ImmutableSortedSet.naturalOrder(); for (Class<?> clazz : imports) { sortedImports.add(clazz.getSimpleName()); } return sortedImports.build(); }
/** * 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(); }
public void run() { set = ImmutableSortedSet.<T> naturalOrder().addAll(Iterables.filter(set, new Predicate<T>() { public boolean apply(final T input) { return !t.equals(input); } })).build(); } });
private static ImmutableSet<String> getDeclaredOutputFilePaths(TaskInternal task, StringInterner stringInterner) { ImmutableSet.Builder<String> declaredOutputFilePaths = ImmutableSortedSet.naturalOrder(); for (File file : task.getOutputs().getFiles()) { declaredOutputFilePaths.add(stringInterner.intern(file.getAbsolutePath())); } return declaredOutputFilePaths.build(); }
private static Set<Integer> getValidArgsSizes(Signature[] signatures) { ImmutableSortedSet.Builder<Integer> builder = ImmutableSortedSet.naturalOrder(); for (Signature signature : signatures) { builder.add(signature.parameterTypes().length); } return builder.build(); }
public T get() { set = ImmutableSortedSet.<T> naturalOrder().addAll(set).add(t).build(); return t; } });
public SortedSet<ConfigRecord<?>> inspect(ConfigurationFactory configurationFactory) { ImmutableSortedSet.Builder<ConfigRecord<?>> builder = ImmutableSortedSet.naturalOrder(); for (ConfigurationProvider<?> configurationProvider : configurationFactory.getConfigurationProviders()) { ConfigRecord<?> result = new ConfigRecord<>(configurationFactory, configurationProvider); builder.add(result); } return builder.build(); }
protected SortedSet<ScopeService> getRequiredServices() { ImmutableSortedSet.Builder<ScopeService> services = ImmutableSortedSet.naturalOrder(); services.addAll(super.getRequiredServices()); services.add( ScopeService.DESKTOP_WINDOW_MANAGER, ScopeService.SYSTEM_INPUT, ScopeService.DESKTOP_UTILS ); return services.build(); }