/*
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.flex.compiler.internal.targets;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.apache.flex.compiler.definitions.IDefinition;
import org.apache.flex.compiler.definitions.references.IResolvedQualifiersReference;
import org.apache.flex.compiler.definitions.references.ReferenceFactory;
import org.apache.flex.compiler.exceptions.BuildCanceledException;
import org.apache.flex.compiler.internal.graph.LinkReportWriter;
import org.apache.flex.compiler.internal.projects.CompilerProject;
import org.apache.flex.compiler.internal.projects.DependencyGraph;
import org.apache.flex.compiler.internal.projects.LibraryPathManager;
import org.apache.flex.compiler.internal.resourcebundles.ResourceBundleUtils;
import org.apache.flex.compiler.internal.units.SWCCompilationUnit;
import org.apache.flex.compiler.internal.workspaces.Workspace;
import org.apache.flex.compiler.problems.ICompilerProblem;
import org.apache.flex.compiler.problems.ResourceBundleNotFoundForLocaleProblem;
import org.apache.flex.compiler.problems.ResourceBundleNotFoundProblem;
import org.apache.flex.compiler.problems.UnableToCreateLinkReportProblem;
import org.apache.flex.compiler.targets.ITarget;
import org.apache.flex.compiler.targets.ITargetProgressMonitor;
import org.apache.flex.compiler.targets.ITargetReport;
import org.apache.flex.compiler.targets.ITargetSettings;
import org.apache.flex.compiler.units.ICompilationUnit;
import org.apache.flex.compiler.units.requests.IFileScopeRequestResult;
import org.apache.flex.compiler.units.requests.IOutgoingDependenciesRequestResult;
import org.apache.flex.swc.ISWC;
import org.apache.flex.swc.ISWCLibrary;
import org.apache.flex.swc.ISWCManager;
import org.apache.flex.swc.ISWCScript;
import org.apache.flex.utils.FileID;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Sets;
/**
* Abstract base class to help subclasses implement ITarget.
*/
public abstract class Target implements ITarget
{
/**
* Find all the externally visible definitions in the given compilation unit
* list.
*
* @param compilationUnits A collection of compilation units.
* @return All the externally visible definitions in the given compilation
* unit list.
* @throws InterruptedException Concurrency error.
*/
public static ImmutableList<IDefinition> getAllExternallyVisibleDefinitions(
final Collection<ICompilationUnit> compilationUnits)
throws InterruptedException
{
assert compilationUnits != null : "Expected collection of compilation units.";
final ImmutableList.Builder<IDefinition> builder = new ImmutableList.Builder<IDefinition>();
for (final ICompilationUnit compilationUnit : compilationUnits)
{
final IFileScopeRequestResult result = compilationUnit.getFileScopeRequest().get();
builder.addAll(result.getExternallyVisibleDefinitions());
}
return builder.build();
}
/**
* Constructor
*
* @param project {@link CompilerProject} that this target will be a part of.
* @param targetSettings {@link ITargetSettings} for this target
* @param progressMonitor {@link ITargetProgressMonitor} that will receive
* progress information. Can be null, in which case no progress information
* will be collected.
*/
protected Target(CompilerProject project, ITargetSettings targetSettings, ITargetProgressMonitor progressMonitor)
{
this.project = project;
this.progressMonitor = progressMonitor;
this.targetSettings = targetSettings;
if (targetSettings.getASMetadataNames() != null)
this.addASMetadataNames(targetSettings.getASMetadataNames());
}
protected final CompilerProject project;
protected final ITargetProgressMonitor progressMonitor;
protected final ITargetSettings targetSettings;
private LinkageChecker linkageChecker;
private Set<String> metadataNames;
private BuiltCompilationUnitSet builtCompilationUnits;
/**
* Lazily initialized {@link Iterable} of fatal {@link ICompilerProblem}s
*/
private Iterable<ICompilerProblem> fatalProblems;
/**
* Lazily initialized target report.
*/
private ITargetReport targetReport;
/**
* Discovers dependent compilation units from a set of root compilation
* units. The return collection includes all compilation units in the
* argument collection.
* <p>
* This method delegates the dependency discovery to
* {@link Target#getDependentCompilationUnits}. Subclasses should override
* this method if they have more sophisticated dependency discovery
* algorithms.
*
* @param compilationUnits {@link ICompilationUnit}s known to be linked into
* the target. Dependent compilation units will be added to this method.
* @param problems Problems building compilation units.
* @return All compilation units to link into the target. This collection
* includes all elements in the {@code compilationUnits} collection from
* argument.
* @throws InterruptedException Concurrency error.
*/
protected Set<ICompilationUnit> findAllCompilationUnitsToLink(final Collection<ICompilationUnit> compilationUnits,
final Collection<ICompilerProblem> problems)
throws InterruptedException
{
assert compilationUnits != null : "compilation units can't be null";
assert problems != null : "problems can't be null";
final Set<ICompilationUnit> allCompilationUnitsInTarget =
new HashSet<ICompilationUnit>(compilationUnits);
final Set<ICompilationUnit> dependencies =
getDependentCompilationUnits(allCompilationUnitsInTarget, problems);
allCompilationUnitsInTarget.addAll(dependencies);
return allCompilationUnitsInTarget;
}
/**
* Waits for the specified {@link ICompilationUnit} to finish building and
* add any problems found in the specified {@link ICompilationUnit} to the
* specified {@link Collection}.
* <p>
* This method exists for the sole purpose of allowing the
* {@link FlexLibrarySWFTarget} to filter out
* {@link ResourceBundleNotFoundProblem}s and
* {@link ResourceBundleNotFoundForLocaleProblem}s from
* {@link SWCCompilationUnit}'s that are externally linked.
* <p>
* If we rip out support for Flex or if we are willing to report missing
* resource bundles from external SWCs when linking a SWC, this method can
* be inlined at its call site.
* <p>
* If we plan on continuing to support Flex, a better way to do this would
* be to have the {@link IOutgoingDependenciesRequestResult} interface have method
* to get all the resource bundles referenced by an {@link ICompilationUnit}
* and wait to do the final resolution of resource bundles in {@link Target}
* or one of its sub-classes.
*
* @param cu
* @param problems
* @throws InterruptedException
*/
protected void waitForCompilationUnitToFinish(final ICompilationUnit cu, final Collection<ICompilerProblem> problems) throws InterruptedException
{
cu.waitForBuildFinish(problems, getTargetType());
}
/**
* Triggers all the request method on all the compilation units and collect
* problems from the project and the compilation units.
* <p>
* Although CSS can introduce dependent classes to be linked into the
* target, the order of root classes and the dependencies doesn't matter. As
* a result, there's no need to add dependency edges for
* {@link DependencyGraph#topologicalSort()}.
*
* @param problems Problems will be returned here.
* @param compilationUnits Compilation units to compile.
* @throws InterruptedException
*/
private void buildCompilationUnits(
final Collection<ICompilationUnit> compilationUnits,
final Collection<ICompilerProblem> problems)
throws InterruptedException
{
assert compilationUnits != null : "Expected compilation units.";
assert problems != null : "Expected problem collection.";
project.collectProblems(problems);
// Parallelize the building of compilation units.
for (final ICompilationUnit cu : compilationUnits)
{
if(isCanceled())
throw new BuildCanceledException();
cu.startBuildAsync(getTargetType());
}
int numCompilationUnit = compilationUnits.size();
//As described in #updateProgress(int, int, int), each compilation unit
//is considered to have two steps. The first step is considered completed
//at the end of handle semantic analysis and the second is considered
//completed when a compilation unit is fully compiled. We know that at
//this moment, semantic analysis phase of all the known compilation units
//would be completed successfully. Therefore, we assume that half of the
//work we need to do in order to compile all the compilation units has
//been done. Therefore, set the value to be the number of compilation unit
//will be included in the build process.
int totalCompUnitWorkCompleted = compilationUnits.size();
// Wait for all compilation units to finish building.
for (final ICompilationUnit cu : compilationUnits)
{
waitForCompilationUnitToFinish(cu, problems);
//Update the progress as we finished compiling a compilation unit.
if(!updateProgress(numCompilationUnit, totalCompUnitWorkCompleted++, 95))
return;
}
}
@Override
public ITargetSettings getTargetSettings()
{
return targetSettings;
}
protected abstract ITargetReport computeTargetReport() throws InterruptedException;
@Override
public final ITargetReport getTargetReport() throws InterruptedException
{
if (targetReport == null)
{
project.getWorkspace().startBuilding();
try
{
targetReport = computeTargetReport();
}
finally
{
project.getWorkspace().doneBuilding();
}
}
return targetReport;
}
/**
* Discovers all the compilation units (roots and dependencies) that will be
* linked into the target. Then builds these compilation units for all
* phases of processing.
*
* @return A {@link BuiltCompilationUnitSet} that contains information about
* all the {@link ICompilationUnit}s whose output contribute to this target
* and {@link ICompilerProblem}s discovered while building all the
* {@link ICompilationUnit}s.
* @throws InterruptedException Concurrency error.
*/
protected BuiltCompilationUnitSet buildAllCompilationUnits() throws InterruptedException
{
Iterable<ICompilerProblem> fatalProblems = getFatalProblems();
if (!Iterables.isEmpty(fatalProblems))
return new BuiltCompilationUnitSet(ImmutableSet.<ICompilationUnit>of(), Collections.<ICompilerProblem>emptyList());
final HashSet<ICompilationUnit> compilationUnits = new HashSet<ICompilationUnit>();
final ArrayList<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
RootedCompilationUnits rootedCompilationUnits = getRootedCompilationUnits();
compilationUnits.addAll(rootedCompilationUnits.getUnits());
compilationUnits.addAll(findAllCompilationUnitsToLink(compilationUnits, problems));
buildCompilationUnits(compilationUnits, problems);
return new BuiltCompilationUnitSet(ImmutableSet.<ICompilationUnit>copyOf(compilationUnits), problems);
}
protected BuiltCompilationUnitSet getBuiltCompilationUnitSet() throws InterruptedException
{
if (builtCompilationUnits == null)
builtCompilationUnits = buildAllCompilationUnits();
return builtCompilationUnits;
}
/**
* Computes the set of all all {@link ICompilationUnit}'s whose output is
* part of the output of this target. This method does <b>NOT</b> compute
* the dependencies introduced in CSS.
*
* @param compilationUnits A collection of root compilation units.
* @param problems Problems building compilation units.
* @return Set of all {@link ICompilationUnit}'s whose output is part of the
* output of this target. The order of compilation units in this function
* does not matter because we topologically sort the dependency graph later
* when we are getting ready to add tags to the output SWF or SWC.
* @throws InterruptedException
*/
protected final Set<ICompilationUnit> getDependentCompilationUnits(
final Collection<ICompilationUnit> compilationUnits,
final Collection<ICompilerProblem> problems)
throws InterruptedException
{
final HashSet<ICompilationUnit> workSet = new HashSet<ICompilationUnit>();
final HashSet<ICompilationUnit> visitedSet = new HashSet<ICompilationUnit>();
int numCompUnitRemoved = 0;
workSet.addAll(compilationUnits);
while (workSet.size() > 0)
{
final ICompilationUnit currentUnit = workSet.iterator().next();
workSet.remove(currentUnit);
if (visitedSet.add(currentUnit))
{
//Increment num of the comp units removed from the workset,
//so that we can calculate the total number of compilation units.
//The reason we only increment it in this if block is that if
//we don't hit in this if block, it means that we had removed
//the same compilation unit before anyways, so we already
//have taken it into account.
numCompUnitRemoved++;
currentUnit.startBuildAsync(getTargetType());
final DirectDependencies currentUnitDependencies = getDirectDependencies(currentUnit);
final Iterable<ICompilationUnit> newCompilationUnitWork = currentUnitDependencies.dependencies;
Iterables.addAll(problems, currentUnitDependencies.problems);
for (ICompilationUnit cu : newCompilationUnitWork)
{
workSet.add(cu);
cu.startBuildAsync(getTargetType());
}
//Update the progress since we completed semantic analysis for one
//compilation unit and possibly found more compilation units.
if(!updateProgress((workSet.size()+numCompUnitRemoved), visitedSet.size(), 50))
return Collections.emptySet();
}
}
return visitedSet;
}
protected DirectDependencies getDirectDependencies(ICompilationUnit cu) throws InterruptedException
{
final Set<ICompilationUnit> dependencies = project.getDependencies(cu);
return new DirectDependencies(dependencies, Collections.<ICompilerProblem>emptyList());
}
/**
* @return All the reachable compilation units in this job.
*/
public ImmutableList<ICompilationUnit> getReachableCompilationUnits(Collection<ICompilerProblem> problems) throws InterruptedException
{
RootedCompilationUnits rootedCompilationUnits = getRootedCompilationUnits();
final Set<ICompilationUnit> root = rootedCompilationUnits.getUnits();
Iterables.addAll(problems, rootedCompilationUnits.getProblems());
final List<ICompilationUnit> reachableCompilationUnitsInSWFOrder = project.getReachableCompilationUnitsInSWFOrder(root);
final ImmutableList<ICompilationUnit> compilationUnits = ImmutableList.<ICompilationUnit> copyOf(reachableCompilationUnitsInSWFOrder);
return compilationUnits;
}
/**
* Create a link report at the path setup in the
* targetSettings.getLinkReportPath. This method may be called after a
* target has been built.
*
* @param problems
* @throws InterruptedException
*/
protected void createLinkReport(Collection<ICompilerProblem> problems) throws InterruptedException
{
if (targetSettings.getLinkReport() != null)
{
OutputStream outStream;
try
{
outStream = new FileOutputStream(targetSettings.getLinkReport());
// Ignore the problems found by getReachableCompilationUnits(). Those problems
// should have already been found by the build.
Collection<ICompilerProblem> reachableProblems = new ArrayList<ICompilerProblem>();
LinkReportWriter reportWriter = new LinkReportWriter(project.getDependencyGraph(),
getReachableCompilationUnits(reachableProblems),
getLinkageChecker());
reportWriter.writeToStream(outStream, problems);
}
catch (FileNotFoundException e)
{
final ICompilerProblem problem = new UnableToCreateLinkReportProblem(
targetSettings.getLinkReport().getAbsolutePath());
problems.add(problem);
}
}
}
/**
* Computes the set of compilation units that root the dependency walk. The
* returned set of compilation units and their dependencies will be
* compiled.
*
* @return The set of rooted {@link ICompilationUnit}'s.
*/
protected abstract RootedCompilationUnits computeRootedCompilationUnits() throws InterruptedException;
public abstract RootedCompilationUnits getRootedCompilationUnits() throws InterruptedException;
/**
* Gets a set of {@link ICompilationUnit}s that are included into the build
* process by -include-classes compiler argument.
* <p>
* This method is marked final until we have a use case to make it
* non-final.
*
* @return a set of {@link ICompilationUnit}s that are included into the
* build process by -include-classes compiler argument.
*/
public final Set<ICompilationUnit> getIncludesCompilationUnits() throws InterruptedException
{
Workspace workspace = project.getWorkspace();
Set<IResolvedQualifiersReference> includesReferences = new HashSet<IResolvedQualifiersReference>();
for (String className : targetSettings.getIncludes())
{
IResolvedQualifiersReference ref = ReferenceFactory.packageQualifiedReference(workspace, className);
includesReferences.add(ref);
}
return project.getScope().getCompilationUnitsForReferences(includesReferences);
}
/**
* @return a collection of resource bundle compilation units that are included
* into the build process by -include-resource-bundles compiler argument.
*/
public final Collection<ICompilationUnit> getIncludedResourceBundlesCompilationUnits(Collection<ICompilerProblem> problems) throws InterruptedException
{
Set<ICompilationUnit>includedResourceBundleCompUnits = new HashSet<ICompilationUnit>();
for (String bundleName : targetSettings.getIncludeResourceBundles())
{
includedResourceBundleCompUnits.addAll(ResourceBundleUtils.findCompilationUnits(bundleName, project, problems));
}
return includedResourceBundleCompUnits;
}
/**
* Get the set of metadata names.
*
* @return The set of metadata names that will be preserved in a SWF
* target or recorded in a SWC target. May be null if all metadata
* names should be kept.
*/
@Override
public final Set<String> getASMetadataNames()
{
return metadataNames;
}
/**
* Add metadata names to the target.
*
* @param metadataNames metadata names that should be kept. May not be null.
*/
public void addASMetadataNames(Collection<String> metadataNames)
{
assert metadataNames != null;
if (this.metadataNames == null)
this.metadataNames = new HashSet<String>();
this.metadataNames.addAll(metadataNames);
}
/**
* The value that represents the percentage of the main task that has been
* completed so far. It should be between 0 and 100.
*/
private int percentCompleted = 0;
/**
* Gets called when build operation starts.
*/
protected final void buildStarted()
{
if(progressMonitor != null)
{
percentCompleted = 0;
}
project.getWorkspace().startBuilding();
}
/**
* Updates the value that represents the percentage of the work completed so
* far using the information specified and notifies the progress monitor
* about this value. Each compilation unit is assumed to complete 2 steps in
* order to be considered compiled. The first step is considered to be done
* when the semantic analysis phase is done. ( @see
* CompilationUnitBase#handleOutgoingDependenciesRequest ). The second step
* starts with byte code generation ( @see
* CompilationUnitBase#handleABCBytesRequest ) and ends when swf tags
* request is completed. ( @see CompilationUnitBase#handleSWFTagsRequest )
*
* @param numTotalCompilationUnits number of compilation units known to be
* included in the build process
* @param totalCompilationUnitsWorkCompleted total compilation unit work
* completed so far. As described above, each compilation unit has two steps.
* Therefore, this value would be equal to (2*numTotalCompilationUnits),
* when we are done with compiling all the compilation units.
* @param maxPercentage the value that represents the maximum percentage of
* the work can be considered completed so far in this method. This
* method guarantees not to report a percentage value that is higher than
* this value as completed to its clients via its progress monitor.
* @return whether or not the build operation should continue.
* <code>false</code> if the build operation has been requested to be
* terminated, <code>true</code> otherwise.
*/
protected boolean updateProgress(int numTotalCompilationUnits,
int totalCompilationUnitsWorkCompleted, int maxPercentage)
{
if(progressMonitor != null)
{
int percentage = (50 * totalCompilationUnitsWorkCompleted) / numTotalCompilationUnits;
if(percentage > maxPercentage)
percentage = maxPercentage;
if(percentCompleted < percentage)
{
percentCompleted = percentage;
progressMonitor.percentCompleted(this, percentCompleted);
}
return !isCanceled();
}
return true;
}
/**
* Updates the value that represents the percentage of the main task that
* has been completed so far and notifies the progress monitor about this
* value if any.
*
* @param percentageCompleted the percentage of the main task that has been
* completed so far.
* @return whether or not the build operation should continue.
* <code>false</code> if the build operation has been requested to be
* terminated, <code>true</code> otherwise.
*/
protected boolean updateProgress(int percentageCompleted)
{
if(progressMonitor != null)
{
if(this.percentCompleted < percentageCompleted)
{
this.percentCompleted = percentageCompleted;
progressMonitor.percentCompleted(this, percentageCompleted);
}
return !isCanceled();
}
return true;
}
/**
* @return returns whether the current compilation operation has been
* requested to be canceled.
*/
protected boolean isCanceled()
{
if(progressMonitor != null)
return progressMonitor.isCanceled(this);
return false;
}
/**
* Gets called when build operation finishes.
*/
protected final void buildFinished()
{
if(progressMonitor != null)
{
percentCompleted = 100;
progressMonitor.done(this);
}
project.getWorkspace().doneBuilding();
}
/**
* Determine if a compilation unit should be linked into the target.
*
* @param cu The compilation unit to test.
* @param targetSettings The target settings.
* @return true if the compilation unit's linkage is external, false
* otherwise.
* @throws InterruptedException
*/
protected boolean isLinkageExternal(ICompilationUnit cu,
ITargetSettings targetSettings) throws InterruptedException
{
return getLinkageChecker().isExternal(cu);
}
/**
* Get the target's linkage checker.
*
* @return the target's linkage checker.
*/
protected final LinkageChecker getLinkageChecker()
{
if (linkageChecker == null)
linkageChecker = new LinkageChecker(project, targetSettings);
return linkageChecker;
}
/**
* Set the project's linkage checker.
*
* @param linkageChecker linkage checker, may not be null.
*/
protected void setLinkageChecker(LinkageChecker linkageChecker)
{
// validate we are using just one linkage checker for
// the life of a target.
assert this.linkageChecker == null;
this.linkageChecker = linkageChecker;
assert this.linkageChecker != null;
}
protected Iterable<ICompilerProblem> getFatalProblems() throws InterruptedException
{
if (fatalProblems == null)
fatalProblems = computeFatalProblems();
return fatalProblems;
}
/**
* Computes an {@link Iterable} of fatal {@link ICompilerProblem}s that
* prevent this {@link Target} from being built.
* <p>
* Sub-classes override this method to check for additional fatal
* {@link ICompilerProblem}s.
*
* @return {@link Iterable} of fatal {@link ICompilerProblem}s
* @throws InterruptedException
*/
protected Iterable<ICompilerProblem> computeFatalProblems() throws InterruptedException
{
return ImmutableList.copyOf(project.getFatalProblems());
}
/**
* Get a collection of compilation units for all of the classes found in
* all of the libraries found in the -include-libraries path.
*
* @return collection of compilation units for all the classes found on
* the -include-libraries path.
*/
protected final Collection<ICompilationUnit> getIncludeLibrariesCompilationUnits()
{
//Collection<ICompilationUnit> units = new HashSet<ICompilationUnit>();
Set<IResolvedQualifiersReference> includeLibrariesReferences = new HashSet<IResolvedQualifiersReference>();
// Find all of the libraries on the -include-library path
Set<FileID> swcs = LibraryPathManager.discoverSWCFilePaths(
targetSettings.getIncludeLibraries().toArray(new File[0]));
// For each library, get a compilation unit for every class in the
// library.
ISWCManager swcManager = project.getWorkspace().getSWCManager();
Workspace w = project.getWorkspace();
for (FileID swcPath : swcs)
{
File swcFile =swcPath.getFile();
// If the SWC does not exist on disk, just ignore it for now, and a
// problem will be created later on during the LibraryPathManager.collectionProblems() call.
if (!swcFile.exists())
continue;
ISWC swc = swcManager.get(swcFile);
for (ISWCLibrary library : swc.getLibraries())
{
for (ISWCScript script : library.getScripts())
{
for (String def : script.getDefinitions())
{
IResolvedQualifiersReference definitionRef =
ReferenceFactory.packageQualifiedReference(w, def);
includeLibrariesReferences.add(definitionRef);
}
}
}
}
return project.getScope().getCompilationUnitsForReferences(includeLibrariesReferences);
}
/**
* Wad that holds a set of {@link ICompilationUnit}s that have been built to
* build the output of this target and any {@link ICompilerProblem}s found
* building those {@link ICompilationUnit}s.
*/
protected static final class BuiltCompilationUnitSet
{
BuiltCompilationUnitSet(ImmutableSet<ICompilationUnit> compilationUnits, Iterable<ICompilerProblem> problems)
{
this.compilationUnits = compilationUnits;
this.problems = problems;
}
public final ImmutableSet<ICompilationUnit> compilationUnits;
final Iterable<ICompilerProblem> problems;
}
/**
* Wad containing the set of {@link ICompilationUnit}s that root the dependency walk
* and any {@link ICompilerProblem}s encountered computing the roots of the
* dependency walk. The returned set of compilation units and their
* dependencies will be compiled.
*
*/
public static final class RootedCompilationUnits
{
static RootedCompilationUnits concat(RootedCompilationUnits base, Set<ICompilationUnit> units, Iterable<ICompilerProblem> problems)
{
return new RootedCompilationUnits(Sets.union(base.units, units), Iterables.concat(base.problems, problems));
}
public RootedCompilationUnits(Set<ICompilationUnit> units, Iterable<ICompilerProblem> problems)
{
assert units != null;
assert problems != null;
this.units = units;
this.problems = problems;
}
private final Set<ICompilationUnit> units;
private final Iterable<ICompilerProblem> problems;
public Set<ICompilationUnit> getUnits()
{
return units;
}
public Iterable<ICompilerProblem> getProblems()
{
return problems;
}
}
/**
* Wad containing an {@link Iterable} of {@link ICompilationUnit}s and an
* {@link Iterable} of {@link ICompilerProblem}s found while constructing
* the {@link Iterable} of {@link ICompilationUnit}s.
* <p>
* The {@link Iterable} of {@link ICompilationUnit}s iterates over all the
* {@link ICompilationUnit}s that are directly depended on by another
* {@link ICompilationUnit}.
*/
public static class DirectDependencies
{
DirectDependencies(Iterable<ICompilationUnit> dependencies, Iterable<ICompilerProblem> problems)
{
this.dependencies = dependencies;
this.problems = problems;
}
/**
* Creates a new {@link DirectDependencies} object that is the concatenation of two other
* {@link DirectDependencies} objects.
* @param a
* @param b
* @return a new {@link DirectDependencies} object that is the concatenation of two other
* {@link DirectDependencies} objects.
*/
static DirectDependencies concat(DirectDependencies a, DirectDependencies b)
{
return new DirectDependencies(Iterables.concat(a.dependencies, b.dependencies), Iterables.concat(a.problems, b.problems));
}
final Iterable<ICompilationUnit> dependencies;
final Iterable<ICompilerProblem> problems;
}
}