ClasspathEntry.java

package runjettyrun.tabs.classpath;

import java.util.List;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.launching.RuntimeClasspathEntry;
import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
import org.eclipse.jdt.launching.JavaRuntime;

import runjettyrun.utils.RunJettyRunClasspathResolver;
import runjettyrun.utils.RunJettyRunClasspathUtil;

public class ClasspathEntry extends AbstractClasspathEntry implements
		IRuntimeClasspathEntry, IAdaptable {

	private IRuntimeClasspathEntry entry = null;

	private boolean isUnderMavenDependency;

	/*
	 * (non-Javadoc)
	 *
	 * @see org.eclipse.jdt.launching.IRuntimeClasspathEntry#getJavaProject()
	 */
	public IJavaProject getJavaProject() {
		return entry.getJavaProject();
	}

	public ClasspathEntry(IRuntimeClasspathEntry entry,
			IRJRClasspathEntry parent) {
		this.parent = parent;
		this.entry = entry;
	}

	public boolean isMissing(){
		return entry instanceof MissingRuntimeClasspathEntry;
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	public boolean equals(Object obj) {
		if (obj instanceof ClasspathEntry) {
			ClasspathEntry other = (ClasspathEntry) obj;

			if(entry.getType() == IRuntimeClasspathEntry.CONTAINER 	&& other.getType() == IRuntimeClasspathEntry.CONTAINER ){
				//If there are all M2E container , we considering if they were in the project. (key will be the same).
				return this.getKey().equals(other.getKey());
			}

			if (entry != null) {
				return entry.equals(other.entry);
			}
		} else if (obj instanceof IRuntimeClasspathEntry) {
			return entry.equals(obj);
		}
		return false;

	}

	/*
	 * (non-Javadoc)
	 *
	 * @see java.lang.Object#hashCode()
	 */
	public int hashCode() {
		return entry.hashCode();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		return entry.getPath().toOSString();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see org.eclipse.jdt.launching.IRuntimeClasspathEntry#getType()
	 */
	public int getType() {
		return entry.getType();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see org.eclipse.jdt.launching.IRuntimeClasspathEntry#getMemento()
	 */
	public String getMemento() throws CoreException {
		return entry.getMemento();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see org.eclipse.jdt.launching.IRuntimeClasspathEntry#getPath()
	 */
	public IPath getPath() {
		return entry.getPath();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see org.eclipse.jdt.launching.IRuntimeClasspathEntry#getResource()
	 */
	public IResource getResource() {
		return entry.getResource();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.eclipse.jdt.launching.IRuntimeClasspathEntry#getSourceAttachmentPath
	 * ()
	 */
	public IPath getSourceAttachmentPath() {
		return entry.getSourceAttachmentPath();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.eclipse.jdt.launching.IRuntimeClasspathEntry#setSourceAttachmentPath
	 * (org.eclipse.core.runtime.IPath)
	 */
	public void setSourceAttachmentPath(IPath path) {
		entry.setSourceAttachmentPath(path);
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.eclipse.jdt.launching.IRuntimeClasspathEntry#getSourceAttachmentRootPath
	 * ()
	 */
	public IPath getSourceAttachmentRootPath() {
		return entry.getSourceAttachmentRootPath();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.eclipse.jdt.launching.IRuntimeClasspathEntry#setSourceAttachmentRootPath
	 * (org.eclipse.core.runtime.IPath)
	 */
	public void setSourceAttachmentRootPath(IPath path) {
		entry.setSourceAttachmentRootPath(path);

	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.eclipse.jdt.launching.IRuntimeClasspathEntry#getClasspathProperty()
	 */
	public int getClasspathProperty() {
		return entry.getClasspathProperty();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.eclipse.jdt.launching.IRuntimeClasspathEntry#setClasspathProperty
	 * (int)
	 */
	public void setClasspathProperty(int location) {
		entry.setClasspathProperty(location);

	}

	/*
	 * (non-Javadoc)
	 *
	 * @see org.eclipse.jdt.launching.IRuntimeClasspathEntry#getLocation()
	 */
	public String getLocation() {
		return entry.getLocation();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.eclipse.jdt.launching.IRuntimeClasspathEntry#getSourceAttachmentLocation
	 * ()
	 */
	public String getSourceAttachmentLocation() {
		return entry.getSourceAttachmentLocation();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see org.eclipse.jdt.launching.IRuntimeClasspathEntry#
	 * getSourceAttachmentRootLocation()
	 */
	public String getSourceAttachmentRootLocation() {
		return entry.getSourceAttachmentRootLocation();
	}

	public String getVariableName() {
		return entry.getVariableName();
	}

	public IClasspathEntry getClasspathEntry() {
		return entry.getClasspathEntry();
	}

	public IRuntimeClasspathEntry getDelegate() {
		return entry;
	}

	public boolean hasChildren() {
		IRuntimeClasspathEntry delegate = getDelegate();
		if (delegate.getType() == IRuntimeClasspathEntry.ARCHIVE) {
			return false;
		} else {
			return true;
		}
	}

	public IRJRClasspathEntry[] getChildren(ILaunchConfiguration configuration) {

		try {
			IRuntimeClasspathEntry delegate = getDelegate();
			if (delegate.getType() == IRuntimeClasspathEntry.PROJECT) {
				List<IRuntimeClasspathEntry> childs;
				IResource ir = delegate.getResource();
				IJavaProject project = JavaCore.create(ir.getProject());
				childs = RunJettyRunClasspathUtil
						.getProjectClasspathsForUserlibs(project, isUnderMavenDependency);
				return create(childs, isUnderMavenDependency);

			} else if (delegate.getType() == IRuntimeClasspathEntry.CONTAINER) {

				// Note: 2011/12/14 Tony:
				// Here the reason we also handle the webapplication container
				// for maven resolving issue is,
				// the web app is impossible to have project as web app .

				// In general case , WTP resolved jars in WEB-INF/lib ,
				// when we have M2E to resolved pom file , sometimes it will
				// load dependency in WEBAPP Container ,

				// yep , it's weird , I mean it should only use existing M2E
				// Container ,
				// but it does happened in some case , I decide to check the
				// project entry in WEB APP Conainer.

				// There shouldn't be proejct entrys in general case, so it
				// should be working fine.
				if (RunJettyRunClasspathResolver.isM2EMavenContainer(delegate)
						|| RunJettyRunClasspathResolver
								.isWebAppContainer(delegate)) {
					IClasspathContainer container = JavaCore
							.getClasspathContainer(delegate.getPath(),
									delegate.getJavaProject());
					if (container == null) {
						return null;
					}
					IClasspathEntry[] cpes = container.getClasspathEntries();
					if (cpes == null || cpes.length == 0) {
						return null;
					}
					IRuntimeClasspathEntry[] entries = new IRuntimeClasspathEntry[cpes.length];
					for (int i = 0; i < cpes.length; ++i) {
						IClasspathEntry cpy = cpes[i];
						entries[i] = new RuntimeClasspathEntry(cpy);
					}
					return create(entries, true);
				}
			}
			IRuntimeClasspathEntry[] entries = JavaRuntime
					.resolveRuntimeClasspathEntry(delegate, configuration);
			if (entries != null && entries.length == 1 && entries[0] == entry) { // same
																					// one
				return new IRJRClasspathEntry[0];
			} else {
				return create(entries, isUnderMavenDependency);
			}
		} catch (CoreException e) {
			return null;
		}
	}

	private IRJRClasspathEntry[] create(List<IRuntimeClasspathEntry> entries,
			boolean maven) {
		return create(entries.toArray(new IRuntimeClasspathEntry[0]), maven);
	}

	private IRJRClasspathEntry[] create(IRuntimeClasspathEntry[] entries,
			boolean maven) {
		ClasspathEntry[] cps = new ClasspathEntry[entries.length];
		for (int i = 0; i < entries.length; i++) {
			IRuntimeClasspathEntry childEntry = entries[i];
			cps[i] = new ClasspathEntry(childEntry, this);
			cps[i].setIsUnderMavenDependency(maven);
			cps[i].setCustom(custom);
		}
		return cps;
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.eclipse.jdt.internal.debug.ui.classpath.IClasspathEntry#isEditable()
	 */
	public boolean isEditable() {
		if (!(getParent() instanceof ClasspathGroup)) {
			return false;
		}

		ClasspathGroup parent = (ClasspathGroup) getParent();
		return parent.isEditable();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
	 */
	public Object getAdapter(@SuppressWarnings("rawtypes") Class adapter) {
		if (getDelegate() instanceof IAdaptable) {
			return ((IAdaptable) getDelegate()).getAdapter(adapter);
		}
		return null;
	}

	public boolean isUnderMavenDependency() {
		return isUnderMavenDependency;
	}

	public void setIsUnderMavenDependency(boolean isUnderMavenDependency) {
		this.isUnderMavenDependency = isUnderMavenDependency;
	}

	public String getRealPath() {
		if(entry == null) return null;

		if(entry.getType() == IRuntimeClasspathEntry.PROJECT){
			return entry.getResource().getLocation().toOSString();
		}else{
			return entry.getLocation();
		}
	}

	public boolean isContainer() {
		return getType() == IRuntimeClasspathEntry.CONTAINER;
	}

	public boolean isDefaultChecked(){
//		if(entry.getType() == IRuntimeClasspathEntry.CONTAINER){
//			return false;
//		}else if(entry.getType() == IRuntimeClasspathEntry.PROJECT){
//			return false;
//		}
		if(toString().endsWith(TEST_CLASSES)){ //default disable test-classes
			return false;
		}
		return true;
	}

	public IPath getExternalAnnotationsPath() {
		// TODO To confirm what we have to do
		return null;
	}

	public void setExternalAnnotationsPath(IPath path) {
		// TODO To confirm what we have to do
	}
}