preverificationbuilder.java

配置文件

/**
 * Copyright (c) 2003-2005 Craig Setera
 * All Rights Reserved.
 * Licensed under the Eclipse Public License - v 1.0
 * For more information see http://www.eclipse.org/legal/epl-v10.html
 */
package eclipseme.core.internal.builder;

import java.util.ArrayList;
import java.util.Map;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;

import eclipseme.core.internal.EclipseMECorePlugin;
import eclipseme.core.internal.preprocessor.PreprocessorBuilder;
import eclipseme.core.internal.utils.AbstractClasspathEntryVisitor;
import eclipseme.core.internal.utils.Utils;
import eclipseme.core.model.IMidletSuiteProject;
import eclipseme.core.model.MidletSuiteFactory;

/**
 * Provides an incremental project builder implementation
 * to do a J2ME preverification of classes.  It is imperative
 * that this builder follow the standard Java builder.  The
 * standard Java builder will generate the standard compiled
 * class.  The preverifier will then preverify that generated
 * class.
 * <p />
 * Copyright (c) 2003-2005 Craig Setera<br>
 * All Rights Reserved.<br>
 * Licensed under the Eclipse Public License - v 1.0<p/>
 * <br>
 * $Revision: 1.16 $
 * <br>
 * $Date: 2006/11/26 21:42:00 $
 * <br>
 * @author Craig Setera
 */
public class PreverificationBuilder extends IncrementalProjectBuilder {
	/**
	 * Implementation of the IClasspathEntryVisitor interface
	 * for collecting the set of required projects
	 */
	private class RequiredProjectsCPEntryVisitor
		extends AbstractClasspathEntryVisitor
	{
		private ArrayList requiredProjects;
		
		/** Construct a new instance. */
		private RequiredProjectsCPEntryVisitor() {
			requiredProjects = new ArrayList();
		}
		
		/**
		 * @return Returns the requiredProjects.
		 */
		public ArrayList getRequiredProjects() {
			return requiredProjects;
		}
		
		/**
		 * @see eclipseme.core.internal.utils.IClasspathEntryVisitor#visitProject(IClasspathEntry, org.eclipse.jdt.core.IJavaProject, org.eclipse.jdt.core.IJavaProject, org.eclipse.core.runtime.IProgressMonitor)
		 */
		public boolean visitProject(
			IClasspathEntry entry,
			IJavaProject javaProject, 
			IJavaProject classpathProject, 
			IProgressMonitor monitor)
				throws CoreException 
		{
			boolean continueVisitation = entry.isExported();
			
			if (continueVisitation) {
				requiredProjects.add(classpathProject);
			}
			
			return continueVisitation;
		}
	}

	/**
	 * Clear the specified container of all resources recursively.
	 * 
	 * @param buildInfo
	 * @param container
	 * @param monitor
	 * @throws CoreException
	 */
	static void clearContainer(BuildInfo buildInfo, IContainer container, IProgressMonitor monitor) 
		throws CoreException 
	{
		Utils.clearContainer(container, monitor);
		buildInfo.setPackageDirty(true);
	}
	
	/**
	 * @see org.eclipse.core.resources.IncrementalProjectBuilder#build(int, java.util.Map, org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected IProject[] build(int kind, Map args, IProgressMonitor monitor)
		throws CoreException 
	{	
		IProject project = getProject();
		if (PreprocessorBuilder.DEBUG) {
			PreprocessorBuilder.DEBUG_WRITER.println("> PrepreverificationBuilder.build; project = " + project); 
		}
		
		IJavaProject rootJavaProject = JavaCore.create(project); 
		IJavaProject javaProject = rootJavaProject;
		IJavaProject[] requiredProjects = getRequiredProjects(javaProject, monitor);

		// TODO Fix monitoring	
		monitor.beginTask("Preverification", requiredProjects.length + 1);
		
		// Start with our project
		BuildInfo buildInfo = new BuildInfo(kind, args,	javaProject);
		preverifyProject(buildInfo, monitor);
		
		// Now prereq projects
		for (int i = 0; i < requiredProjects.length; i++) {
			javaProject = requiredProjects[i];
			if (javaProject != null) {
				buildInfo.setCurrentJavaProject(javaProject);
				preverifyProject(buildInfo, monitor);
			}
		}
		
		// Make sure all of the libraries in the project have been
		// preverified
		if (buildInfo.isClasspathChanged() && buildInfo.areLibrariesPreverified()) {
			IFolder libsFolder = buildInfo.getVerifiedLibsFolder(monitor);
			clearContainer(buildInfo, libsFolder, monitor);

			buildInfo.setCurrentJavaProject(rootJavaProject);
			preverifyLibraries(buildInfo, monitor);

			for (int i = 0; i < requiredProjects.length; i++) {
				javaProject = requiredProjects[i];
				buildInfo.setCurrentJavaProject(javaProject);
				preverifyLibraries(buildInfo, monitor);
			}
		}
		
		// Set all of the resources in the verified path
		// to be derived resources
		setResourcesAsDerived(buildInfo.getVerifiedFolder(monitor), monitor);

		monitor.done();
		
		// Convert to IProject instances 
		IProject[] interestingProjects = new IProject[requiredProjects.length];
		for (int i = 0; i < requiredProjects.length; i++) {
			interestingProjects[i] = requiredProjects[i].getProject();
		}
		
		if (PreprocessorBuilder.DEBUG) {
			PreprocessorBuilder.DEBUG_WRITER.println("< PrepreverificationBuilder.build"); 
		}
		
		return interestingProjects;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.core.internal.events.InternalBuilder#clean(org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected void clean(IProgressMonitor monitor) 
		throws CoreException 
	{
		super.clean(monitor);
		
		// We delete all the verified classes
		IProject project = getProject();
		IMidletSuiteProject midletSuiteProject = 
			MidletSuiteFactory.getMidletSuiteProject(JavaCore.create(project));
		
		// Clear the classes and libraries
		IFolder classesPreverifyFolder = midletSuiteProject.getVerifiedClassesOutputFolder(monitor);
		Utils.clearContainer(classesPreverifyFolder, monitor);
		
		IFolder libsPreverifyFolder = midletSuiteProject.getVerifiedClassesOutputFolder(monitor);
		Utils.clearContainer(libsPreverifyFolder, monitor);
		
		// We also delete the deployed folder
		IFolder deploymentFolder = 
			midletSuiteProject.getProject().getFolder(EclipseMECorePlugin.getDeploymentDirectoryName());
		Utils.clearContainer(deploymentFolder, monitor);		
	}

	/**
	 * Get the projects that are required by the project being built.
	 * 
	 * @param javaProject
	 * @param monitor
	 * @return
	 * @throws CoreException
	 */
	private IJavaProject[] getRequiredProjects(
		IJavaProject javaProject,
		IProgressMonitor monitor)
			throws CoreException 
	{
		RequiredProjectsCPEntryVisitor visitor = new RequiredProjectsCPEntryVisitor();
		visitor.getRunner().run(javaProject, visitor, monitor);

		ArrayList projects = visitor.getRequiredProjects();
		return (IJavaProject[]) projects.toArray(new IJavaProject[projects.size()]);
	}

	/**
	 * Preverify the libraries associated with the current java project
	 * in the build info.
	 * 
	 * @param buildInfo
	 * @param monitor
	 * @throws CoreException
	 */
	private void preverifyLibraries(BuildInfo buildInfo, IProgressMonitor monitor) 
		throws CoreException 
	{
		IProject project = buildInfo.getCurrentJavaProject().getProject();
		
		if (PreprocessorBuilder.DEBUG) {
			PreprocessorBuilder.DEBUG_WRITER.println("> PrepreverificationBuilder.preverifyLibraries; project = " + project); 
		}

		if ((project != null) && project.isAccessible()) {
			monitor.setTaskName("Preverifying " + project.getName());

			// Figure the resource delta to be used
			buildInfo.setCurrentResourceDelta(null);
			if (buildInfo.getBuildKind() != FULL_BUILD) {
				buildInfo.setCurrentResourceDelta(getDelta(project));
			}
			
			// Hand off to the build helper for the heavy lifting
			ResourceDeltaBuilder deltaBuilder = new ResourceDeltaBuilder(buildInfo);
			deltaBuilder.preverifyLibraries(monitor);
			
			monitor.worked(1);
		}		
		
		if (PreprocessorBuilder.DEBUG) {
			PreprocessorBuilder.DEBUG_WRITER.println("< PrepreverificationBuilder.preverifyLibraries"); 
		}
	}
	
	/**
	 * Preverify the project based on the specified build
	 * information.
	 * 
	 * @param buildInfo
	 * @param monitor
	 * @throws CoreException
	 */
	private void preverifyProject(BuildInfo buildInfo, IProgressMonitor monitor) 
		throws CoreException 
	{
		IProject project = buildInfo.getCurrentJavaProject().getProject();
		
		if (PreprocessorBuilder.DEBUG) {
			PreprocessorBuilder.DEBUG_WRITER.println("> PrepreverificationBuilder.preverifyProject; project = " + project); 
		}
		if ((project != null) && project.isAccessible()) {
			monitor.setTaskName("Preverifying " + project.getName());

			// Figure the resource delta to be used
			buildInfo.setCurrentResourceDelta(null);
			if (buildInfo.getBuildKind() != FULL_BUILD) {
				buildInfo.setCurrentResourceDelta(getDelta(project));
			}
			
			// Hand off to the build helper for the heavy lifting
			ResourceDeltaBuilder deltaBuilder = new ResourceDeltaBuilder(buildInfo);
			deltaBuilder.build(monitor);
		}		
		
		if (PreprocessorBuilder.DEBUG) {
			PreprocessorBuilder.DEBUG_WRITER.println("< PrepreverificationBuilder.preverifyProject"); 
		}
	}
	
	/**
	 * Set the resources in the output directory to 
	 * be derived so they are left alone by the team support.
	 * 
	 * @param verifiedFolder
	 * @param monitor
	 * @throws CoreException
	 */
	private void setResourcesAsDerived(
		IFolder verifiedFolder,
		IProgressMonitor monitor)
			throws CoreException 
	{
		// Refresh from the folder down so that we can
		// set derived on these...
		verifiedFolder.refreshLocal(IResource.DEPTH_INFINITE, monitor);
				
		// Get the starting folder
		EclipseMECorePlugin.setResourcesAsDerived(verifiedFolder);
	}
}