下面列出了com.google.common.collect.ImmutableSortedSet#naturalOrder ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
* Helper method that returns a combined set of the common fragments all genrules require plus
* instance-specific requirements passed here.
*/
private ImmutableSortedSet<String> genRuleFragments(String... targetSpecificRequirements)
throws Exception {
scratch.file(
"base_genrule/BUILD",
"genrule(",
" name = 'base_genrule',",
" srcs = [],",
" outs = ['base_genrule.out'],",
" cmd = 'echo hi > [email protected]')");
ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.naturalOrder();
builder.add(targetSpecificRequirements);
builder.addAll(
getConfiguredTarget("//base_genrule")
.getProvider(RequiredConfigFragmentsProvider.class)
.getRequiredConfigFragments());
return builder.build();
}
/**
* Calculate the distances between a given tokenable city hex
* and all other tokenable city hexes.
* <p> Distances are cached.
* @param initHex Start hex
* @return Sorted integer list containing all occurring distances only once.
*/
public SortedSet<Integer> getCityDistances (MapHex initHex) {
if (hexDistances == null) {
hexDistances = HashBasedTable.create();
}
if (!hexDistances.containsRow(initHex)) {
calculateHexDistances(initHex, initHex, 0);
}
ImmutableSortedSet.Builder<Integer> distances =
ImmutableSortedSet.naturalOrder();
for (Entry<MapHex, Integer> otherHex:hexDistances.row(initHex).entrySet()) {
if (otherHex.getKey().getCurrentTile().hasStations()) {
distances.add(otherHex.getValue());
}
}
return distances.build();
}
@Test
public void testOutputFormatStringDifferentOutputFileNameThinRules() {
ProjectFilesystem filesystem = new FakeProjectFilesystem();
SourcePathResolverAdapter pathResolver = newSourcePathResolver();
ImmutableSortedSet.Builder<SourcePath> inputsBuilder = ImmutableSortedSet.naturalOrder();
inputsBuilder.add(PathSourcePath.of(filesystem, Paths.get("libNiceLibrary.a")));
inputsBuilder.add(PathSourcePath.of(filesystem, Paths.get("libBadLibrary.a")));
ImmutableSortedSet<SourcePath> inputs = inputsBuilder.build();
String outputFormatString =
MultiarchFileInfos.getMultiarchOutputFormatString(pathResolver, inputs);
assertThat(outputFormatString, equalTo("%s"));
}
private static SortedSet<Integer> presidentSellStandard(PublicCompany company, Player president) {
int presidentShares = president.getPortfolioModel().getShareNumber(company);
int poolShares = poolAllowsShareNumbers(company);
// check if there is a potential new president ...
int presidentCertificateShares = company.getPresidentsShare().getShares();
Player potential = company.findPlayerToDump();
int maxShares;
if (potential == null) {
// ... if there is none, selling is only possible until the presidentCerificate or pool maximum
maxShares = Math.min(presidentShares - presidentCertificateShares, poolShares);
} else {
// otherwise until pool maximum only
maxShares = Math.min(presidentShares, poolShares);
}
ImmutableSortedSet.Builder<Integer> sharesToSell = ImmutableSortedSet.naturalOrder();
for (int s=1; s <= maxShares; s++) {
sharesToSell.add(s);
}
return sharesToSell.build();
}
protected static BoundingBox calculateBoundingBoxLineStrings(Iterable<LineString> lineStrings) {
ImmutableSortedSet.Builder<Float> xset =
ImmutableSortedSet.naturalOrder();
ImmutableSortedSet.Builder<Float> yset =
ImmutableSortedSet.naturalOrder();
ImmutableSortedSet.Builder<Float> zset =
ImmutableSortedSet.naturalOrder();
for (LineString ls : lineStrings) {
for (Position p : ls) {
xset.add(p.northing());
yset.add(p.easting());
if (p.hasAltitude())
zset.add(p.altitude());
}
}
return buildBoundingBox(
xset.build(),
yset.build(),
zset.build());
}
public UtilsResourceMount() {
ImmutableSortedSet.Builder<String> files = ImmutableSortedSet.naturalOrder();
InputStream fileList = getClass().getResourceAsStream(RESOURCE_PATH + "files.lst");
if (fileList != null) {
Scanner sc = new Scanner(fileList);
while (sc.hasNextLine()) {
String fileName = sc.nextLine();
files.add(fileName);
}
sc.close();
}
this.files = files.build();
}
@Test
public void testNames()
throws Exception
{
final State state = getState();
final byte[] value = "The quick brown fox jumps over the lazy dog.".getBytes(StandardCharsets.UTF_8);
final ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.naturalOrder();
for (int i = 0; i < 10; i++) {
final String key = "name-" + UUID.randomUUID().toString();
builder.add(key);
final Variable var = state.fetch(key).get();
assertTrue(var.value().length == 0);
state.store(var.mutate(value)).get();
}
final SortedSet<String> keys = builder.build();
final Iterator<String> it = state.names().get();
final SortedSet<String> entries = ImmutableSortedSet.copyOf(it);
assertEquals(keys, entries);
}
public ImmutableSortedSet construct(int entries) {
ImmutableSortedSet.Builder builder = ImmutableSortedSet.<Comparable>naturalOrder();
for (int i = 0; i < entries; i++) {
builder.add(newEntry());
}
return builder.build();
}
/**
* Provides {@see BuildRule} set of abi dependencies that have desugar enabled on them.
*
* <p>These are the deps that are required for full desugaring of default and static interface
* methods
*/
private static ImmutableSortedSet<BuildRule> getDesugarDeps(
JavaLibrary javaLibrary, Function<BuildTarget, BuildRule> targetToRule) {
ImmutableSortedSet.Builder<BuildRule> resultBuilder = ImmutableSortedSet.naturalOrder();
for (JavaLibrary library :
JavaLibraryClasspathProvider.getTransitiveClasspathDeps(javaLibrary)) {
if (javaLibrary != library && library.isDesugarEnabled()) {
library
.getAbiJar()
.ifPresent(buildTarget -> resultBuilder.add(targetToRule.apply(buildTarget)));
}
}
return resultBuilder.build();
}
@Test
public void testOutputFormatStringEmptyThinRules() {
SourcePathResolverAdapter pathResolver = newSourcePathResolver();
ImmutableSortedSet.Builder<SourcePath> inputsBuilder = ImmutableSortedSet.naturalOrder();
ImmutableSortedSet<SourcePath> inputs = inputsBuilder.build();
String outputFormatString =
MultiarchFileInfos.getMultiarchOutputFormatString(pathResolver, inputs);
assertThat(outputFormatString, equalTo("%s"));
}
public ImmutableSortedSet<String> getModuleNames() {
ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.naturalOrder();
for (HaskellSourceModule module : getModuleMap().keySet()) {
if (module.getSourceType() == HaskellSourceModule.SourceType.HsSrcFile) {
builder.add(module.getModuleName());
}
}
return builder.build();
}
/**
* @param srcs the set of the sources of a rule attribute
* @param deps the {@link ProviderInfoCollection} from the dependencies of a rule
* @return the {@link Artifact}s representing the sources.
*/
public static ImmutableSortedSet<Artifact> getArtifactsFromSrcs(
Iterable<SourcePath> srcs, ImmutableMap<BuildTarget, ProviderInfoCollection> deps) {
ImmutableSortedSet.Builder<Artifact> artifacts = ImmutableSortedSet.naturalOrder();
for (SourcePath src : srcs) {
artifacts.add(SourceArtifactConverter.getArtifactsFromSrc(src, deps));
}
return artifacts.build();
}
@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 List<String> computeParameterOrder(ApiMethodConfig methodConfig) {
ImmutableSortedSet.Builder<String> queryParamBuilder = ImmutableSortedSet.naturalOrder();
Collection<String> pathParameters = methodConfig.getPathParameters();
for (ApiParameterConfig parameterConfig : methodConfig.getParameterConfigs()) {
if (parameterConfig.getClassification() == Classification.API_PARAMETER
&& !pathParameters.contains(parameterConfig.getName())
&& !parameterConfig.getNullable()) {
queryParamBuilder.add(parameterConfig.getName());
}
}
List<String> order = new ArrayList<>(pathParameters);
order.addAll(queryParamBuilder.build());
return order;
}
@Test
public void depsHaveStripAndDebugFlavorsPropagatedForPlatformDeps() {
BuildTarget bundleTargetWithStripFlavor =
BuildTargetFactory.newInstance("//bar:bundle#iphoneos-arm64,strip-all,dwarf-and-dsym");
BuildTarget unflavoredDep = BuildTargetFactory.newInstance("//bar:dep1");
BuildTarget unflavoredDepAfterPropagation =
BuildTargetFactory.newInstance("//bar:dep1#iphoneos-arm64,strip-all,dwarf-and-dsym");
BuildTarget flavoredDep =
BuildTargetFactory.newInstance("//bar:dep2#iphoneos-armv7,strip-debug,dwarf");
BuildTarget flavoredDepNotInDomain = BuildTargetFactory.newInstance("//bar:dep3#otherflavor");
BuildTarget flavoredDepNotInDomainAfterPropagation =
BuildTargetFactory.newInstance(
"//bar:dep3#iphoneos-arm64,strip-all,dwarf-and-dsym,otherflavor");
BuildTarget stripFlavorOnly = BuildTargetFactory.newInstance("//bar:dep4#strip-debug");
BuildTarget stripFlavorOnlyAfterPropagation =
BuildTargetFactory.newInstance("//bar:dep4#iphoneos-arm64,strip-debug,dwarf-and-dsym");
BuildTarget debugFlavorOnly = BuildTargetFactory.newInstance("//bar:dep5#dwarf");
BuildTarget debugFlavorOnlyAfterPropagation =
BuildTargetFactory.newInstance("//bar:dep5#iphoneos-arm64,strip-all,dwarf");
BuildTarget binary = BuildTargetFactory.newInstance("//bar:binary");
AppleBundleDescription desc = FakeAppleRuleDescriptions.BUNDLE_DESCRIPTION;
AppleBundleDescriptionArg constructorArg =
AppleBundleDescriptionArg.builder()
.setName("bundle")
.setExtension(Either.ofLeft(AppleBundleExtension.BUNDLE))
.setInfoPlist(FakeSourcePath.of("Info.plist"))
.setPlatformBinary(
PatternMatchedCollection.<BuildTarget>builder()
.add(Pattern.compile("iphoneos-arm64"), binary)
.build())
.setDeps(
ImmutableSortedSet.<BuildTarget>naturalOrder()
.add(binary)
.add(unflavoredDep)
.add(flavoredDep)
.add(flavoredDepNotInDomain)
.add(stripFlavorOnly)
.add(debugFlavorOnly)
.build())
.build();
// Now call the find deps methods and verify it returns the targets with flavors.
ImmutableSortedSet.Builder<BuildTarget> implicitDeps = ImmutableSortedSet.naturalOrder();
desc.findDepsForTargetFromConstructorArgs(
bundleTargetWithStripFlavor,
createCellRoots(filesystem).getCellNameResolver(),
constructorArg,
implicitDeps,
ImmutableSortedSet.naturalOrder());
assertEquals(
ImmutableSortedSet.<BuildTarget>naturalOrder()
.add(unflavoredDepAfterPropagation)
.add(flavoredDep)
.add(flavoredDepNotInDomainAfterPropagation)
.add(stripFlavorOnlyAfterPropagation)
.add(debugFlavorOnlyAfterPropagation)
.build(),
implicitDeps.build());
}
@Test
public void pendingWorkIsCancelledOnFailures() throws Exception {
String description = "failing step";
AtomicInteger failedSteps = new AtomicInteger(0);
Step failingStep =
new AbstractExecutionStep(description) {
@Override
public StepExecutionResult execute(ExecutionContext context) {
System.out.println("Failing");
failedSteps.incrementAndGet();
return StepExecutionResults.ERROR;
}
};
ImmutableSortedSet.Builder<BuildRule> depsBuilder = ImmutableSortedSet.naturalOrder();
for (int i = 0; i < 20; i++) {
BuildRule failingDep =
createRule(
filesystem,
graphBuilder,
/* deps */ ImmutableSortedSet.of(),
/* buildSteps */ ImmutableList.of(failingStep),
/* postBuildSteps */ ImmutableList.of(),
/* pathToOutputFile */ null,
ImmutableList.of(InternalFlavor.of("failing-" + i)));
graphBuilder.addToIndex(failingDep);
depsBuilder.add(failingDep);
}
FakeBuildRule withFailingDeps =
new FakeBuildRule(
BuildTargetFactory.newInstance("//:with_failing_deps"), depsBuilder.build());
// Use a CommandThreadManager to closely match the real-world CachingBuildEngine experience.
// Limit it to 1 thread so that we don't start multiple deps at the same time.
try (CommandThreadManager threadManager =
new CommandThreadManager(
"cachingBuildEngingTest",
new ConcurrencyLimit(
1,
ResourceAllocationFairness.FAIR,
1,
ResourceAmounts.of(100, 100, 100, 100),
ResourceAmounts.of(0, 0, 0, 0)))) {
CachingBuildEngine cachingBuildEngine =
cachingBuildEngineFactory()
.setExecutorService(threadManager.getWeightedListeningExecutorService())
.build();
BuildResult result =
cachingBuildEngine
.build(buildContext, TestExecutionContext.newInstance(), withFailingDeps)
.getResult()
.get();
assertThat(result.getStatus(), equalTo(BuildRuleStatus.FAIL));
assertThat(result.getFailure(), instanceOf(BuildRuleFailedException.class));
Throwable cause = result.getFailure().getCause();
assertThat(cause, instanceOf(StepFailedException.class));
assertThat(failedSteps.get(), equalTo(1));
assertThat(((StepFailedException) cause).getStep().getShortName(), equalTo(description));
}
}
public static CxxLinkAndCompileRules createBuildRulesForCxxBinaryDescriptionArg(
TargetGraph targetGraph,
BuildTarget target,
ProjectFilesystem projectFilesystem,
ActionGraphBuilder graphBuilder,
CellPathResolver cellRoots,
CxxBuckConfig cxxBuckConfig,
CxxPlatform cxxPlatform,
CommonArg args,
ImmutableSet<BuildTarget> extraDeps,
Optional<StripStyle> stripStyle,
Optional<LinkerMapMode> flavoredLinkerMapMode) {
ImmutableMap<String, CxxSource> srcs = parseCxxSources(target, graphBuilder, cxxPlatform, args);
ImmutableMap<Path, SourcePath> headers =
parseHeaders(target, graphBuilder, projectFilesystem, Optional.of(cxxPlatform), args);
// Build the binary deps.
ImmutableSortedSet.Builder<BuildRule> depsBuilder = ImmutableSortedSet.naturalOrder();
// Add original declared and extra deps.
args.getCxxDeps().get(graphBuilder, cxxPlatform).forEach(depsBuilder::add);
// Add in deps found via deps query.
ImmutableList<BuildRule> depQueryDeps =
args.getDepsQuery().map(query -> Objects.requireNonNull(query.getResolvedQuery()))
.orElse(ImmutableSortedSet.of()).stream()
.map(graphBuilder::getRule)
.collect(ImmutableList.toImmutableList());
depsBuilder.addAll(depQueryDeps);
// Add any extra deps passed in.
extraDeps.stream().map(graphBuilder::getRule).forEach(depsBuilder::add);
ImmutableSortedSet<BuildRule> deps = depsBuilder.build();
CxxLinkOptions linkOptions =
CxxLinkOptions.of(
args.getThinLto(),
args.getFatLto()
);
Optional<LinkableListFilter> linkableListFilter =
LinkableListFilterFactory.from(cxxBuckConfig, args, targetGraph);
return createBuildRulesForCxxBinary(
target,
projectFilesystem,
graphBuilder,
cellRoots,
cxxBuckConfig,
cxxPlatform,
srcs,
headers,
deps,
args.getLinkDepsQueryWhole()
? RichStream.from(depQueryDeps).map(BuildRule::getBuildTarget).toImmutableSet()
: ImmutableSet.of(),
stripStyle,
flavoredLinkerMapMode,
args.getLinkStyle().orElse(Linker.LinkableDepType.STATIC),
linkableListFilter,
linkOptions,
args.getPreprocessorFlags(),
args.getPlatformPreprocessorFlags(),
args.getLangPreprocessorFlags(),
args.getLangPlatformPreprocessorFlags(),
args.getFrameworks(),
args.getLibraries(),
args.getCompilerFlags(),
args.getLangCompilerFlags(),
args.getPlatformCompilerFlags(),
args.getLangPlatformCompilerFlags(),
args.getPrefixHeader(),
args.getPrecompiledHeader(),
args.getLinkerFlags(),
args.getLinkerExtraOutputs(),
args.getPlatformLinkerFlags(),
args.getCxxRuntimeType(),
args.getRawHeaders(),
args.getIncludeDirectories(),
args.getExecutableName());
}
@Override
public BuildRule createBuildRule(
BuildRuleCreationContextWithTargetGraph context,
BuildTarget buildTarget,
BuildRuleParams params,
GwtBinaryDescriptionArg args) {
ActionGraphBuilder graphBuilder = context.getActionGraphBuilder();
ImmutableSortedSet.Builder<BuildRule> extraDeps = ImmutableSortedSet.naturalOrder();
// Find all of the reachable JavaLibrary rules and grab their associated GwtModules.
ImmutableSortedSet.Builder<SourcePath> gwtModuleJarsBuilder = ImmutableSortedSet.naturalOrder();
ImmutableSortedSet<BuildRule> moduleDependencies =
graphBuilder.getAllRules(args.getModuleDeps());
new AbstractBreadthFirstTraversal<BuildRule>(moduleDependencies) {
@Override
public Iterable<BuildRule> visit(BuildRule rule) {
if (!(rule instanceof JavaLibrary)) {
return ImmutableSet.of();
}
JavaLibrary javaLibrary = (JavaLibrary) rule;
Iterable<BuildRule> ruleDeps = javaLibrary.getDepsForTransitiveClasspathEntries();
// If the java library doesn't generate any output, it doesn't contribute a GwtModule
if (javaLibrary.getSourcePathToOutput() == null) {
return ruleDeps;
}
BuildRule gwtModule =
graphBuilder.computeIfAbsent(
javaLibrary
.getBuildTarget()
.assertUnflavored()
.withFlavors(JavaLibrary.GWT_MODULE_FLAVOR),
gwtModuleTarget -> {
ImmutableSortedSet<SourcePath> filesForGwtModule =
ImmutableSortedSet.<SourcePath>naturalOrder()
.addAll(javaLibrary.getSources())
.addAll(javaLibrary.getResources())
.build();
ImmutableSortedSet<BuildRule> deps =
ImmutableSortedSet.copyOf(
graphBuilder.filterBuildRuleInputs(filesForGwtModule));
return new GwtModule(
gwtModuleTarget,
context.getProjectFilesystem(),
params.withDeclaredDeps(deps).withoutExtraDeps(),
graphBuilder,
filesForGwtModule,
javaLibrary.getResourcesRoot());
});
extraDeps.add(gwtModule);
gwtModuleJarsBuilder.add(Objects.requireNonNull(gwtModule.getSourcePathToOutput()));
Optional<SourcePath> generatedCode = javaLibrary.getGeneratedAnnotationSourcePath();
if (generatedCode.isPresent()) {
extraDeps.add(javaLibrary);
gwtModuleJarsBuilder.add(generatedCode.get());
}
// Traverse all of the deps of this rule.
return ruleDeps;
}
}.start();
return new GwtBinary(
buildTarget,
context.getProjectFilesystem(),
params.withExtraDeps(extraDeps.build()),
args.getModules(),
javaOptions
.apply(buildTarget.getTargetConfiguration())
.getJavaRuntimeLauncher(graphBuilder, buildTarget.getTargetConfiguration()),
args.getVmArgs(),
args.getStyle().orElse(DEFAULT_STYLE),
args.getDraftCompile().orElse(DEFAULT_DRAFT_COMPILE),
args.getOptimize().orElse(DEFAULT_OPTIMIZE),
args.getLocalWorkers().orElse(DEFAULT_NUM_LOCAL_WORKERS),
args.getStrict().orElse(DEFAULT_STRICT),
args.getExperimentalArgs(),
gwtModuleJarsBuilder.build());
}
@VisibleForTesting
static BlockingProperties findBlockingPropsForLine(
int blockedLineNum, List<PermitAndDenyBdds> bdds) {
PermitAndDenyBdds blockedLine = bdds.get(blockedLineNum);
ImmutableSortedSet.Builder<LineAndWeight> linesByWeight =
ImmutableSortedSet.orderedBy(LineAndWeight.COMPARATOR);
// First, we find all lines before blockedLine that actually terminate any packets
// blockedLine intends to. These, collectively, are the (partially-)blocking lines.
//
// In this same loop, we also compute the overlap of each such line with the blocked line
// and weight each blocking line by that overlap.
//
// Finally, we record whether any of these lines has a different action than the blocked line.
PermitAndDenyBdds restOfLine = blockedLine;
boolean diffAction = false; // true if some partially-blocking line has a different action.
for (int prevLineNum = 0; prevLineNum < blockedLineNum && !restOfLine.isZero(); prevLineNum++) {
PermitAndDenyBdds prevLine = bdds.get(prevLineNum);
if (!prevLine.getMatchBdd().andSat(restOfLine.getMatchBdd())) {
continue;
}
BDD blockedLineOverlap = prevLine.getMatchBdd().and(blockedLine.getMatchBdd());
linesByWeight.add(new LineAndWeight(prevLineNum, blockedLineOverlap.satCount()));
diffAction = diffAction || takeDifferentActions(prevLine, restOfLine);
restOfLine = restOfLine.diff(prevLine.getMatchBdd());
}
// In this second loop, we compute the answer:
// * include partially-blocking lines in weight order until the blocked line is fully blocked by
// this subset.
// * also include the largest blocking line with a different action than the blocked line, if
// not already in the above subset.
ImmutableSortedSet.Builder<Integer> answerLines = ImmutableSortedSet.naturalOrder();
restOfLine = blockedLine;
boolean needDiffAction = diffAction;
for (LineAndWeight line : linesByWeight.build()) {
int curLineNum = line.getLine();
PermitAndDenyBdds curLine = bdds.get(curLineNum);
boolean curDiff = takeDifferentActions(curLine, blockedLine);
// The original line is still not blocked, or this is the first line with a different action.
if (!restOfLine.isZero() || needDiffAction && curDiff) {
restOfLine = restOfLine.diff(curLine.getMatchBdd());
answerLines.add(curLineNum);
needDiffAction = needDiffAction && !curDiff;
}
// The original line is blocked and we have a line with a different action (if such exists).
if (restOfLine.isZero() && !needDiffAction) {
break;
}
}
return new BlockingProperties(answerLines.build(), diffAction);
}
/**
* Scans a sequence of import lines. The parsing uses this approximate grammar:
* <p>
* <pre>{@code
* <imports> -> (<end-of-line> | <import>)*
* <import> -> "import" <whitespace> ("static" <whitespace>)?
* <identifier> ("." <identifier>)* ("." "*")? <whitespace>? ";"
* <whitespace>? <line-comment>? <end-of-line>
* }</pre>
*
* @param i the index to start parsing at.
* @return the result of parsing the imports.
* @throws FormatterException if imports could not parsed according to the grammar.
*/
private ImportsAndIndex scanImports(int i) throws FormatterException {
int afterLastImport = i;
ImmutableSortedSet.Builder<Import> imports = ImmutableSortedSet.naturalOrder();
// JavaInput.buildToks appends a zero-width EOF token after all tokens. It won't match any
// of our tests here and protects us from running off the end of the toks list. Since it is
// zero-width it doesn't matter if we include it in our string concatenation at the end.
while (i < toks.size() && tokenAt(i).equals("import")) {
i++;
if (isSpaceToken(i)) {
i++;
}
boolean isStatic = tokenAt(i).equals("static");
if (isStatic) {
i++;
if (isSpaceToken(i)) {
i++;
}
}
if (!isIdentifierToken(i)) {
throw new FormatterException("Unexpected token after import: " + tokenAt(i));
}
StringAndIndex imported = scanImported(i);
String importedName = imported.string;
i = imported.index;
if (isSpaceToken(i)) {
i++;
}
if (!tokenAt(i).equals(";")) {
throw new FormatterException("Expected ; after import");
}
while (tokenAt(i).equals(";")) {
// Extra semicolons are not allowed by the JLS but are accepted by javac.
i++;
}
StringBuilder trailing = new StringBuilder();
if (isSpaceToken(i)) {
trailing.append(tokenAt(i));
i++;
}
if (isSlashSlashCommentToken(i)) {
trailing.append(tokenAt(i));
i++;
}
if (!isNewlineToken(i)) {
throw new FormatterException("Extra tokens after import: " + tokenAt(i));
}
trailing.append(tokenAt(i));
i++;
imports.add(new Import(importedName, trailing.toString(), isStatic));
// Remember the position just after the import we just saw, before skipping blank lines.
// If the next thing after the blank lines is not another import then we don't want to
// include those blank lines in the text to be replaced.
afterLastImport = i;
while (isNewlineToken(i) || isSpaceToken(i)) {
i++;
}
}
return new ImportsAndIndex(imports.build(), afterLastImport);
}