import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
/**
 * Converts the {@link VertexOrder vertex order} into the appropriate {@link ProjectBuildConfigOrder build
 * configuration order}.
 *
 * @param order
 *            the order to convert.
 * @return the converted vertex order as a build configuration order. The returning configuration can be consumed by
 *         the Eclipse build framework.
 */
private static ProjectBuildConfigOrder vertexOrderToProjectBuildConfigOrder(final VertexOrder order) {
	final IBuildConfiguration[] buildConfigs = new IBuildConfiguration[order.vertexes.length];
	System.arraycopy(order.vertexes, 0, buildConfigs, 0, order.vertexes.length);
	final IBuildConfiguration[][] knots = new IBuildConfiguration[order.knots.length][];
	for (int i = 0; i < order.knots.length; i++) {
		knots[i] = new IBuildConfiguration[order.knots[i].length];
		System.arraycopy(order.knots[i], 0, knots[i], 0, order.knots[i].length);
	}
	return new ProjectBuildConfigOrder(buildConfigs, order.hasCycles, knots);
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
@Override
public int compare(final IBuildConfiguration px, final IBuildConfiguration py) {
	int cmp = py.getProject().getName().compareTo(px.getProject().getName());
	if (cmp == 0) {
		cmp = py.getName().compareTo(px.getName());
	}
	return cmp;
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
/**
 * Like {@link #getActiveBuildConfig()} but doesn't check accessibility. Project must be accessible.
 *
 * @see #getActiveBuildConfig()
 */
/* default */ IBuildConfiguration unsafeGetActiveBuildConfig() {
	String configName = internalGetDescription().getActiveBuildConfig();
	try {
		if (configName != null)
			return getBuildConfig(configName);
	} catch (CoreException e) {
		// Build configuration doesn't exist; treat the first as active.
	}
	return internalGetBuildConfigs(false)[0];
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
/**
 * Creates a new job with the already ordered configurations to builder.
 *
 * @param configs
 *            the configurations to build.
 *
 */
public RebuildWorkspaceProjectsJob(final IBuildConfiguration[] configs) {
	super("Building workspace");
	checkState(Platform.isRunning(), "This job requires a running platform");
	this.configs = checkNotNull(configs, "configs");
	setSystem(false);
	setUser(true);
	setRule(BUILD_RULE);
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
/**
 * Schedules a build with the given projects. Does nothing if the {@link Platform platform} is not running, or the
 * iterable of projects is empty.
 *
 * @param toUpdate
 *            an iterable of projects to build.
 */
public void scheduleBuildIfNecessary(final Iterable<IProject> toUpdate) {
	if (Platform.isRunning() && !Iterables.isEmpty(toUpdate)) {
		final Workspace workspace = (Workspace) ResourcesPlugin.getWorkspace();
		final IBuildConfiguration[] projectsToReBuild = from(asList(workspace.getBuildOrder()))
				.filter(config -> Iterables.contains(toUpdate, config.getProject()))
				.toArray(IBuildConfiguration.class);

		if (!Arrays2.isEmpty(projectsToReBuild)) {
			new RebuildWorkspaceProjectsJob(projectsToReBuild).schedule();
		}
	}
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
@Override
public IBuildConfiguration[] internalGetReferencedBuildConfigs(final String configName,
		final boolean includeMissing) {

	final IBuildConfiguration[] filteredConfigs = from(referencedBuildConfigs)
			.filter(config -> !includeMissing ? config.getProject().exists() : true)
			.toArray(IBuildConfiguration.class);
	return filteredConfigs;
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
private void refreshAndFullBuild(IProgressMonitor monitor) throws InvocationTargetException {
	
	List<IProject> projects = Arrays.asList(ResourcesPlugin.getWorkspace().getRoot().getProjects());
	boolean isAutoBuildEnabled = isAutoBuildEnabled();	
	 try
     {
		 if (isAutoBuildEnabled)
		 {
			 enableAutoBuild(false);
		 }
		
		// refresh all projects one by one  
		for (IProject project : projects)
		{
			if (project.isOpen())
			{
				project.refreshLocal(IResource.DEPTH_INFINITE, null);
			}
		}
		// do a full build
        ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.CLEAN_BUILD, monitor);
        IBuildConfiguration[] platformBuildConfig = { ResourcesPlugin.getWorkspace().newBuildConfig("platform","platform-build")};
        // build the platform first since other projects depend on it
        ResourcesPlugin.getWorkspace().build(platformBuildConfig, IncrementalProjectBuilder.FULL_BUILD, true, monitor);
        ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, monitor);
      }
      catch (CoreException e)
      {
    	Activator.logError("Failed to synchronize with the platform", e);
        throw new InvocationTargetException(e);
      }
	 if (isAutoBuildEnabled)
	 {
		 enableAutoBuild(true);
	 }
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
@Override
public void build(
    IBuildConfiguration[] iBuildConfigurations,
    int i,
    boolean b,
    IProgressMonitor iProgressMonitor)
    throws CoreException {
  throw new UnsupportedOperationException();
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
protected boolean isFirstProjectOfKind() throws CoreException {
	for (IBuildConfiguration buildConfig : getContext().getAllReferencedBuildConfigs()) {
		if(buildConfig.getProject().hasNature(LangCore.NATURE_ID)) {
			return false;
		}
	}
	return true;
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
protected boolean isLastProjectOfKind() throws CoreException {
	for (IBuildConfiguration buildConfig : getContext().getAllReferencingBuildConfigs()) {
		if(buildConfig.getProject().hasNature(LangCore.NATURE_ID)) {
			return false;
		}
	}
	return true;
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
@Override
public IBuildConfiguration getActiveBuildConfig() throws CoreException {
	return new BuildConfiguration(this);
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
private void doPerformOperation(final IBuildConfiguration[] configs, final BuildOperation operation,
		final IProgressMonitor monitor) {

	if (Arrays2.isEmpty(configs)) {
		return;
	}

	final ISchedulingRule rule = getRule();
	try {
		Job.getJobManager().beginRule(rule, monitor);

		final List<ExternalProject> projects = transform(configs, config -> (ExternalProject) config.getProject());
		final List<IBuildConfiguration> buildOrder = newArrayList(getBuildOrder(projects));
		if (BuildOperation.CLEAN.equals(operation)) {
			Collections.reverse(buildOrder);
		}

		// Remove external projects that have the workspace counterpart if it is a build operation.
		if (BuildOperation.BUILD.equals(operation)) {
			for (final Iterator<IBuildConfiguration> itr = buildOrder.iterator(); itr.hasNext(); /**/) {
				if (hasWorkspaceCounterpart(itr.next())) {
					itr.remove();
				}
			}
		}

		checkState(buildOrder.size() == configs.length,
				"Inconsistency between build configuration and the ordered projects:" +
						"\n\tInput was: " + getProjectNames(configs) +
						"\n\tOrdered was: " + getProjectNames(buildOrder));

		ensureDynamicDependenciesSetForWorkspaceProjects();
		final String prefix = Strings.toFirstUpper(operation.toString().toLowerCase());
		final String projectNames = getProjectNames(buildOrder);
		LOGGER.info(prefix + "ing external libraries: " + projectNames);
		final SubMonitor subMonitor = SubMonitor.convert(monitor, buildOrder.size());
		for (final IBuildConfiguration configuration : buildOrder) {
			final IProject project = configuration.getProject();
			LOGGER.info(prefix + "ing external library: " + project.getName());
			operation.run(this, project, subMonitor.newChild(1));
		}
	} finally {
		Job.getJobManager().endRule(rule);
	}
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
/**
 * Returns with {@code true} if the external project is accessible in the workspace as well.
 */
private boolean hasWorkspaceCounterpart(IBuildConfiguration config) {
	final URI uri = URI.createPlatformResourceURI(config.getProject().getName(), true);
	final IN4JSProject n4Project = core.findProject(uri).orNull();
	return null != n4Project && n4Project.exists() && !n4Project.isExternal();
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
private String getProjectNames(final Iterable<IBuildConfiguration> buildOrder) {
	return Iterables.toString(from(buildOrder).transform(c -> c.getProject().getName()));
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
private IBuildConfiguration getBuildConfiguration(final IProject project) {
	return TO_CONFIG_FUNC.apply(project);
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
@Override
public void build(
    IBuildConfiguration iBuildConfiguration, int i, IProgressMonitor iProgressMonitor)
    throws CoreException {
  throw new UnsupportedOperationException();
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
@Override
public IBuildConfiguration getActiveBuildConfig() throws CoreException {
  throw new UnsupportedOperationException();
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
@Override
public IBuildConfiguration getBuildConfig(String s) throws CoreException {
  throw new UnsupportedOperationException();
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
@Override
public IBuildConfiguration[] getBuildConfigs() throws CoreException {
  throw new UnsupportedOperationException();
}
 

import org.eclipse.core.resources.IBuildConfiguration; //导入依赖的package包/类
@Override
public IBuildConfiguration[] getReferencedBuildConfigs(String s, boolean b) throws CoreException {
  throw new UnsupportedOperationException();
}