Example usage for com.google.common.collect ImmutableSortedSet.Builder add

List of usage examples for com.google.common.collect ImmutableSortedSet.Builder add

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.collect.*
  5. ImmutableSortedSet.Builder
  6. add

Introduction

In this page you can find the example usage for com.google.common.collect ImmutableSortedSet.Builder add.

Prototype

boolean add(E e);

Source Link

Document

Adds the specified element to this set if it is not already present (optional operation).

Usage

From source file:eu.eidas.auth.commons.attribute.AttributeRegistry.java

@Nonnull
public ImmutableSortedSet<AttributeDefinition<?>> getByFilter(@Nonnull AttributeDefinitionFilter filter) {
    Preconditions.checkNotNull(filter, "filter");
    try {//from   ww w . j ava 2  s .c  o  m
        ImmutableSortedSet.Builder<AttributeDefinition<?>> builder = new ImmutableSortedSet.Builder<>(
                Ordering.natural());
        for (final SingletonAccessor<ImmutableSortedSet<AttributeDefinition<?>>> accessor : getAccessors()) {
            ImmutableSortedSet<AttributeDefinition<?>> attributeDefinitions = accessor.get();
            if (null != attributeDefinitions) {
                for (final AttributeDefinition<?> attributeDefinition : attributeDefinitions) {
                    if (filter.accept(attributeDefinition)) {
                        builder.add(attributeDefinition);
                    }
                }
            }
        }
        return builder.build();
    } catch (IOException ioe) {
        throw new InternalErrorEIDASException(EidasErrorKey.INTERNAL_ERROR.errorCode(), ioe.getMessage(), ioe);
    }
}

From source file:com.chen.mail.ui.NestedFolderTeaserView.java

@Override
public void onGetView() {
    if (mListUpdated) {
        // Clear out the folder views
        mNestedFolderContainer.removeAllViews();

        // Sort the folders by name
        // TODO(skennedy) recents? starred?
        final ImmutableSortedSet.Builder<FolderHolder> folderHoldersBuilder = new ImmutableSortedSet.Builder<FolderHolder>(
                FolderHolder.NAME_COMPARATOR);

        for (int i = 0; i < mFolderHolders.size(); i++) {
            folderHoldersBuilder.add(mFolderHolders.valueAt(i));
        }//from   w w  w .j  a  v a2s. c o m

        final ImmutableSortedSet<FolderHolder> folderHolders = folderHoldersBuilder.build();

        // Add all folder views to the teaser
        int added = 0;
        for (final FolderHolder folderHolder : folderHolders) {
            mNestedFolderContainer.addView(folderHolder.getItemView());
            added++;

            if (added >= sCollapsedFolderThreshold && mCollapsed) {
                // We will display the rest when "Show more" is clicked
                break;
            }
        }

        updateShowMoreView();

        mListUpdated = false;
    }
}

From source file:com.facebook.buck.jvm.java.JavaSymbolFinder.java

/**
 * Find all Java source files that define a given fully-qualified symbol (like "com.example.a.A").
 * To do this, open up all the Java files that could define it (see {@link #getCandidatePaths})
 * and parse them with our Eclipse-based {@link JavaFileParser}.
 *///from  w ww. j  a  va 2s. c o  m
private ImmutableSortedSet<Path> getDefiningPaths(String symbol, Collection<Path> srcRoots) {
    ImmutableSortedSet.Builder<Path> definingPaths = ImmutableSortedSet.naturalOrder();
    // TODO(shs96c): This should use the same javac env as was used for compiling the code.
    JavaFileParser parser = JavaFileParser.createJavaFileParser(javacOptions);

    for (Path candidatePath : getCandidatePaths(symbol, srcRoots)) {
        Optional<String> content = projectFilesystem
                .readFileIfItExists(projectFilesystem.getPathForRelativeExistingPath(candidatePath));
        if (content.isPresent() && parser.getExportedSymbolsFromString(content.get()).contains(symbol)) {
            definingPaths.add(candidatePath);
        }
    }
    return definingPaths.build();
}

From source file:com.facebook.buck.java.JavaSymbolFinder.java

/**
 * Find all Java source files that define a given fully-qualified symbol (like "com.example.a.A").
 * To do this, open up all the Java files that could define it (see {@link #getCandidatePaths})
 * and parse them with our Eclipse-based {@link JavaFileParser}.
 *///w  w  w.  j a  v  a 2 s .  c  o  m
private ImmutableSortedSet<Path> getDefiningPaths(String symbol, Collection<Path> srcRoots) {
    ImmutableSortedSet.Builder<Path> definingPaths = ImmutableSortedSet.naturalOrder();
    // TODO(simons): This should use the same javac env as was used for compiling the code.
    JavaFileParser parser = JavaFileParser.createJavaFileParser(javacOptions);

    for (Path candidatePath : getCandidatePaths(symbol, srcRoots)) {
        String content = projectFilesystem
                .readFileIfItExists(projectFilesystem.getPathForRelativeExistingPath(candidatePath)).get();
        Set<String> symbols = parser.getExportedSymbolsFromString(content);
        if (symbols.contains(symbol)) {
            definingPaths.add(candidatePath);
        }
    }
    return definingPaths.build();
}

From source file:com.facebook.buck.android.AndroidBinaryGraphEnhancer.java

private ImmutableSortedSet<BuildRule> getAdditionalAaptDeps(ImmutableSortedSet<BuildRule> resourceRules) {
    ImmutableSortedSet.Builder<BuildRule> builder = ImmutableSortedSet.<BuildRule>naturalOrder()
            .addAll(resourceRules)/*from  ww w . j  av  a 2 s  . c o m*/
            .addAll(getTargetsAsRules(
                    FluentIterable.from(androidResourceDepsFinder.getAssetOnlyAndroidResources())
                            .transform(HasBuildTarget.TO_TARGET).toList()))
            .addAll(getTargetsAsRules(
                    androidResourceDepsFinder.getAndroidTransitiveDependencies().nativeTargetsWithAssets));
    if (manifest instanceof BuildRuleSourcePath) {
        builder.add(((BuildRuleSourcePath) manifest).getRule());
    }
    return builder.build();
}

From source file:com.facebook.buck.thrift.ThriftJavaEnhancer.java

@Override
public BuildRule createBuildRule(TargetGraph targetGraph, BuildRuleParams params, BuildRuleResolver resolver,
        ThriftConstructorArg args, ImmutableMap<String, ThriftSource> sources,
        ImmutableSortedSet<BuildRule> deps) throws NoSuchBuildTargetException {
    SourcePathRuleFinder ruleFinder = new SourcePathRuleFinder(resolver);

    if (params.getBuildTarget().getFlavors().contains(CalculateAbi.FLAVOR)) {
        BuildTarget libraryTarget = params.getBuildTarget().withoutFlavors(CalculateAbi.FLAVOR);
        resolver.requireRule(libraryTarget);
        return CalculateAbi.of(params.getBuildTarget(), ruleFinder, params,
                new BuildTargetSourcePath(libraryTarget));
    }/*ww  w  .  ja va 2  s.  c o m*/

    // Pack all the generated sources into a single source zip that we'll pass to the
    // java rule below.
    ImmutableSortedSet.Builder<BuildRule> sourceZipsBuilder = ImmutableSortedSet.naturalOrder();
    UnflavoredBuildTarget unflavoredBuildTarget = params.getBuildTarget().getUnflavoredBuildTarget();
    for (ImmutableMap.Entry<String, ThriftSource> ent : sources.entrySet()) {
        String name = ent.getKey();
        BuildRule compilerRule = ent.getValue().getCompileRule();
        Path sourceDirectory = ent.getValue().getOutputDir().resolve("gen-java");

        BuildTarget sourceZipTarget = getSourceZipBuildTarget(unflavoredBuildTarget, name);
        Path sourceZip = getSourceZipOutputPath(params.getProjectFilesystem(), unflavoredBuildTarget, name);

        sourceZipsBuilder.add(new SrcZip(params.copyWithChanges(sourceZipTarget,
                Suppliers.ofInstance(ImmutableSortedSet.of(compilerRule)),
                Suppliers.ofInstance(ImmutableSortedSet.of())), sourceZip, sourceDirectory));
    }
    ImmutableSortedSet<BuildRule> sourceZips = sourceZipsBuilder.build();
    resolver.addAllToIndex(sourceZips);

    // Create to main compile rule.
    BuildRuleParams javaParams = params.copyWithChanges(
            BuildTargets.createFlavoredBuildTarget(unflavoredBuildTarget, getFlavor()),
            Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>naturalOrder().addAll(sourceZips).addAll(deps)
                    .addAll(BuildRules.getExportedRules(deps))
                    .addAll(ruleFinder.filterBuildRuleInputs(templateOptions.getInputs(ruleFinder))).build()),
            Suppliers.ofInstance(ImmutableSortedSet.of()));

    BuildTarget abiJarTarget = params.getBuildTarget().withAppendedFlavors(CalculateAbi.FLAVOR);

    final SourcePathResolver pathResolver = new SourcePathResolver(ruleFinder);

    return new DefaultJavaLibrary(javaParams, pathResolver, ruleFinder,
            FluentIterable.from(sourceZips).transform(SourcePaths.getToBuildTargetSourcePath())
                    .toSortedSet(Ordering.natural()),
            /* resources */ ImmutableSet.of(), templateOptions.getGeneratedSourceFolderName(),
            /* proguardConfig */ Optional.empty(), /* postprocessClassesCommands */ ImmutableList.of(),
            /* exportedDeps */ ImmutableSortedSet.of(), /* providedDeps */ ImmutableSortedSet.of(),
            /* abiJar */ abiJarTarget, JavaLibraryRules.getAbiInputs(resolver, javaParams.getDeps()),
            templateOptions.trackClassUsage(), /* additionalClasspathEntries */ ImmutableSet.of(),
            new JavacToJarStepFactory(templateOptions, JavacOptionsAmender.IDENTITY),
            /* resourcesRoot */ Optional.empty(), /* manifest file */ Optional.empty(),
            /* mavenCoords */ Optional.empty(), /* tests */ ImmutableSortedSet.of(),
            /* classesToRemoveFromJar */ ImmutableSet.of());
}

From source file:com.facebook.buck.java.JavaSymbolFinder.java

/**
 * Guessing file names from fully-qualified Java symbols is ambiguous, because we don't know ahead
 * of time exactly what part of the symbol is the package, and what part is class names or static
 * members. This returns the set of all possible Java files for a given symbol, given different
 * possibilities for the package name and resolving against all the available source roots.
 * Returns only those candidates that actually exist.
 *///from   ww w.j  a  va2s .  c  o  m
private ImmutableSortedSet<Path> getCandidatePaths(String symbol, Collection<Path> srcRoots) {
    ImmutableSortedSet.Builder<Path> candidatePaths = ImmutableSortedSet.naturalOrder();
    List<String> symbolParts = Lists.newArrayList(symbol.split("\\."));
    for (int symbolIndex = 0; symbolIndex < symbolParts.size(); symbolIndex++) {
        List<String> pathPartsList = symbolParts.subList(0, symbolIndex);
        String[] pathParts = pathPartsList.toArray(new String[pathPartsList.size()]);
        String candidateFileName = symbolParts.get(symbolIndex) + ".java";
        for (Path srcRoot : srcRoots) {
            Path candidatePath = srcRoot.resolve(Paths.get("", pathParts)).resolve(candidateFileName);
            if (projectFilesystem.exists(candidatePath)) {
                candidatePaths.add(candidatePath);
            }
        }
    }
    return candidatePaths.build();
}

From source file:simpleserver.config.DTDEntityResolver.java

private ImmutableSet<Integer> parseGroups(String idString) {
    String[] segments = idString.split(",");
    ImmutableSortedSet.Builder<Integer> groups = ImmutableSortedSet.naturalOrder();
    for (String segment : segments) {
        if (segment.matches("^\\s*$")) {
            continue;
        }//from w  ww .  j  a v a  2  s. co m

        try {
            groups.add(Integer.valueOf(segment));
            continue;
        } catch (NumberFormatException e) {
        }

        if (segment.indexOf('+') == segment.length() - 1) {
            int num = 0;
            try {
                num = Integer.valueOf(segment.split("\\+")[0]);
            } catch (NumberFormatException e) {
                System.out.println("Unable to parse group: " + segment);
                continue;
            }
            List ids = config.getList("/groups/group/@id");
            for (int j = 0; j < ids.size(); j++) {
                int n = Integer.valueOf(ids.get(j).toString());
                if (n >= num) {
                    groups.add(n);
                }
            }
            continue;
        }

        String[] range = segment.split("-");
        if (range.length != 2) {
            System.out.println("Unable to parse group: " + segment);
            continue;
        }

        int low;
        int high;
        try {
            low = Integer.valueOf(range[0]);
            high = Integer.valueOf(range[1]);
        } catch (NumberFormatException e) {
            System.out.println("Unable to parse group: " + segment);
            continue;
        }

        if (low > high) {
            System.out.println("Unable to parse group: " + segment);
            continue;
        }

        for (int k = low; k <= high; ++k) {
            groups.add(k);
        }
    }

    return groups.build();
}

From source file:com.palantir.atlasdb.table.description.Schema.java

/**
 * Performs code generation./*from  ww w  . j a va 2  s .  co  m*/
 *
 * @param srcDir root source directory where code generation is performed.
 */
public void renderTables(File srcDir) throws IOException {
    Preconditions.checkNotNull(name, "schema name not set");
    Preconditions.checkNotNull(packageName, "package name not set");

    TableRenderer tableRenderer = new TableRenderer(packageName, namespace);
    for (Entry<String, TableDefinition> entry : tableDefinitions.entrySet()) {
        String rawTableName = entry.getKey();
        TableDefinition table = entry.getValue();
        ImmutableSortedSet.Builder<IndexMetadata> indices = ImmutableSortedSet
                .orderedBy(Ordering.natural().onResultOf(new Function<IndexMetadata, String>() {
                    @Override
                    public String apply(IndexMetadata index) {
                        return index.getIndexName();
                    }
                }));
        if (table.getGenericTableName() != null) {
            Preconditions.checkState(!indexesByTable.containsKey(rawTableName),
                    "Generic tables cannot have indices");
        } else {
            for (String indexName : indexesByTable.get(rawTableName)) {
                indices.add(indexDefinitions.get(indexName).toIndexMetadata(indexName));
            }
        }
        emit(srcDir, tableRenderer.render(rawTableName, table, indices.build()), packageName,
                tableRenderer.getClassName(rawTableName, table));
    }
    for (Entry<String, TableDefinition> entry : tempTableDefinitions.entrySet()) {
        String rawTableName = entry.getKey();
        TableDefinition table = entry.getValue();
        emit(srcDir, tableRenderer.render(rawTableName, table, ImmutableSortedSet.<IndexMetadata>of()),
                packageName, tableRenderer.getClassName(rawTableName, table));
    }

    for (StreamStoreRenderer renderer : streamStoreRenderers) {
        emit(srcDir, renderer.renderStreamStore(), renderer.getPackageName(),
                renderer.getStreamStoreClassName());
        emit(srcDir, renderer.renderIndexCleanupTask(), renderer.getPackageName(),
                renderer.getIndexCleanupTaskClassName());
        emit(srcDir, renderer.renderMetadataCleanupTask(), renderer.getPackageName(),
                renderer.getMetadataCleanupTaskClassName());
    }
    TableFactoryRenderer tableFactoryRenderer = new TableFactoryRenderer(name, packageName, namespace,
            tableDefinitions);
    emit(srcDir, tableFactoryRenderer.render(), tableFactoryRenderer.getPackageName(),
            tableFactoryRenderer.getClassName());
}

From source file:cron.Times.java

public NavigableSet<ZonedDateTime> dateTimes() {
    if (seconds.isEmpty())
        seconds.withRange(0, 1);/*from w ww .jav  a  2 s . c o  m*/
    if (minutes.isEmpty())
        minutes.withRange(0, 1);
    if (hours.isEmpty())
        hours.withRange(0, 1);
    if (months.isEmpty())
        months.withRange(1, 2);
    if (years.isEmpty()) {
        int thisYear = ZonedDateTime.now().getYear();
        years.withRange(thisYear, thisYear + 1);
    }
    ImmutableSortedSet.Builder<ZonedDateTime> builder = ImmutableSortedSet.naturalOrder();
    for (int second : seconds) {
        for (int minute : minutes) {
            for (int hour : hours) {
                for (int month : months) {
                    for (int year : years) {
                        ZonedDateTime base = ZonedDateTime.now().truncatedTo(ChronoUnit.DAYS).withSecond(second)
                                .withMinute(minute).withHour(hour).withMonth(month).withDayOfMonth(1)
                                .withYear(year);
                        if (!daysOfWeek.isEmpty() && !daysOfMonth.isEmpty()) {
                            addDaysOfWeek(builder, base);
                            addDaysOfMonth(builder, base);
                        } else if (!daysOfWeek.isEmpty()) {
                            addDaysOfWeek(builder, base);
                        } else if (!daysOfMonth.isEmpty()) {
                            addDaysOfMonth(builder, base);
                        } else {
                            builder.add(base);
                        }
                    }
                }
            }
        }
    }
    return builder.build();
}