model/org/eclipse/jdt/internal/core/JarPackageFragmentRoot.java - gerrit/e4/org.eclipse.jdt.core - Git at Google

 package org.eclipse.jdt.internal.core;

 /*
  * (c) Copyright IBM Corp. 2000, 2001.
  * All Rights Reserved.
  */
 import org.eclipse.core.runtime.*;
 import org.eclipse.core.resources.*;
 import org.eclipse.jdt.core.*;

 import java.io.*;
 import java.util.*;
 import java.util.zip.*;

 /**
  * A package fragment root that corresponds to a .jar or .zip.
  *
  * <p>NOTE: The only visible entries from a .jar or .zip package fragment root
  * are .class files.
  * <p>NOTE: A jar package fragment root may or may not have an associated resource.
  *
  * @see IPackageFragmentRoot
  * @see JarPackageFragmentRootInfo
  */
 public class JarPackageFragmentRoot extends PackageFragmentRoot {
 	/**
 	 * The absolute path to the jar file.
 	 */
 	protected IPath fJarPath= null;

 	/**
 	 * The delimiter between the zip path and source path in the
 	 * attachment server property.
 	 */
 	protected final static char ATTACHMENT_PROPERTY_DELIMITER= '*';

 	/**
 	 * The name of the meta-inf directory not to be included as a
 	 * jar package fragment.
 	 * @see #computeJarChildren
 	 */
 	//protected final static String META_INF_NAME = "META-INF/";
 	/**
 	 * Constructs a package fragment root which is the root of the Java package directory hierarchy
 	 * based on a JAR file that is not contained in a <code>IJavaProject</code> and
 	 * does not have an associated <code>IResource</code>.
 	 */
 	protected JarPackageFragmentRoot(String jarPath, IJavaProject project) {
 		super(null, project, jarPath);
 		fJarPath= new Path(jarPath);
 	}
 	/**
 	 * Constructs a package fragment root which is the root of the Java package directory hierarchy
 	 * based on a JAR file.
 	 */
 	protected JarPackageFragmentRoot(IResource resource, IJavaProject project) {
 		super(resource, project);
 		fJarPath= resource.getFullPath();
 	}
 	/**
 	 * @see IPackageFragmentRoot
 	 */
 	public void attachSource(IPath zipPath, IPath rootPath, IProgressMonitor monitor) throws JavaModelException {
 		QualifiedName qName= getSourceAttachmentPropertyName();
 		try {
 			verifyAttachSource(zipPath);
 			if (monitor != null) {
 				monitor.beginTask(Util.bind("element.attachingSource"/*nonNLS*/), 2);
 			}
 			SourceMapper mapper= null;
 			SourceMapper oldMapper= getSourceMapper();
 			IWorkspace workspace= getJavaModel().getWorkspace();
 			boolean rootNeedsToBeClosed= false;

 			if (zipPath == null) {
 				//source being detached
 				rootNeedsToBeClosed= true;
 			/* Disable deltas (see 1GDTUSD)
 				// fire a delta to notify the UI about the source detachement.
 				JavaModelManager manager = (JavaModelManager) JavaModelManager.getJavaModelManager();
 				JavaModel model = (JavaModel) getJavaModel();
 				JavaElementDelta attachedSourceDelta = new JavaElementDelta(model);
 				attachedSourceDelta .sourceDetached(this); // this would be a JarPackageFragmentRoot
 				manager.registerResourceDelta(attachedSourceDelta );
 				manager.fire(); // maybe you want to fire the change later. Let us know about it.
 			*/
 			} else {
 			/*
 				// fire a delta to notify the UI about the source attachement.
 				JavaModelManager manager = (JavaModelManager) JavaModelManager.getJavaModelManager();
 				JavaModel model = (JavaModel) getJavaModel();
 				JavaElementDelta attachedSourceDelta = new JavaElementDelta(model);
 				attachedSourceDelta .sourceAttached(this); // this would be a JarPackageFragmentRoot
 				manager.registerResourceDelta(attachedSourceDelta );
 				manager.fire(); // maybe you want to fire the change later. Let us know about it.
 			 */
 				String rootPathString= null;
 				if (rootPath == null) {
 					rootPath= new Path(IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH);
 				}

 				//check if different from the current attachment
 				IPath storedZipPath= getSourceAttachmentPath();
 				IPath storedRootPath= getSourceAttachmentRootPath();
 				if (monitor != null) {
 					monitor.worked(1);
 				}
 				if (storedZipPath != null) {
 					if (!(storedZipPath.equals(zipPath) && rootPath.equals(storedRootPath))) {
 						rootNeedsToBeClosed= true;
 					}
 				}
 				if ((zipPath.isAbsolute() && workspace.getRoot().findMember(zipPath) != null) || !zipPath.isAbsolute()) {
 					// internal to the workbench
 					// a resource
 					IResource zipFile= workspace.getRoot().findMember(zipPath);
 					if (zipFile == null) {
 						if (monitor != null) {
 							monitor.done();
 						}
 						throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.INVALID_PATH, zipPath));
 					}
 					if (!(zipFile.getType() == IResource.FILE)) {
 						if (monitor != null) {
 							monitor.done();
 						}
 						throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.INVALID_PATH, zipPath));
 					}
 				}
 				mapper= new SourceMapper(zipPath, rootPath.toOSString(), (JavaModel) getJavaModel());
 			}
 			setSourceMapper(mapper);
 			if (zipPath == null) {
 				//remove the property
 				getWorkspace().getRoot().setPersistentProperty(qName, null);
 			} else {
 				//set the property to the path of the mapped zip
 				getWorkspace().getRoot().setPersistentProperty(qName, zipPath.toString() + ATTACHMENT_PROPERTY_DELIMITER + rootPath.toString());
 			}
 			if (rootNeedsToBeClosed) {
 				if (oldMapper != null) {
 					oldMapper.close();
 				}
 				IBufferManager manager= BufferManager.getDefaultBufferManager();
 				Enumeration openBuffers= manager.getOpenBuffers();
 				while (openBuffers.hasMoreElements()) {
 					IBuffer buffer= (IBuffer) openBuffers.nextElement();
 					IOpenable possibleJarMember= buffer.getOwner();
 					if (isAncestorOf((IJavaElement) possibleJarMember)) {
 						buffer.close();
 					}
 				}
 				if (monitor != null) {
 					monitor.worked(1);
 				}
 			}
 		} catch (JavaModelException e) {
 			try {
 				getWorkspace().getRoot().setPersistentProperty(qName, null); // loose info - will be recomputed
 			} catch(CoreException ce){
 			}
 			throw e;
 		} catch (CoreException rae) {
 			try {
 				getWorkspace().getRoot().setPersistentProperty(qName, null); // loose info - will be recomputed
 			} catch(CoreException ce){
 			}
 			throw new JavaModelException(rae);
 		} finally {
 			if (monitor != null) {
 				monitor.done();
 			}
 		}
 	}
 	/**
 	 * Close the associated JAR file stored in the info of this element. If
 	 * this jar has an associated ZIP source attachment, close it too.
 	 *
 	 * @see IOpenable
 	 */
 	protected void closing(Object info) throws JavaModelException {
 		SourceMapper mapper= getSourceMapper();
 		if (mapper != null) {
 			mapper.close();
 		}
 		super.closing(info);
 	}
 	/**
 	 * Compute the package fragment children of this package fragment root.
 	 * These are all of the directory zip entries, and any directories implied
 	 * by the path of class files contained in the jar of this package fragment root.
 	 * Has the side effect of opening the package fragment children.
 	 */
 	protected boolean computeChildren(OpenableElementInfo info) throws JavaModelException {
 		Vector vChildren= new Vector();
 		computeJarChildren((JarPackageFragmentRootInfo) info, vChildren);
 		IJavaElement[] children= new IJavaElement[vChildren.size()];
 		vChildren.copyInto(children);
 		info.setChildren(children);
 		return true;
 	}
 /**
  * Determine all of the package fragments associated with this package fragment root.
  * Cache the zip entries for each package fragment in the info for the package fragment.
  * The package fragment children are all opened.
  * Add all of the package fragments to vChildren.
  *
  * @exception JavaModelException The resource (the jar) associated with this package fragment root does not exist
  */
 protected void computeJarChildren(JarPackageFragmentRootInfo info, Vector vChildren) throws JavaModelException {
 	ZipFile jar= null;
 	try {
 		jar= getJar();
 		Hashtable packageFragToTypes= new Hashtable();

 		// always create the default package
 		packageFragToTypes.put(IPackageFragment.DEFAULT_PACKAGE_NAME, new Vector[] { new Vector(), new Vector()
 		});

 		Vector[] temp;
 		for (Enumeration e= jar.entries(); e.hasMoreElements();) {
 			ZipEntry member= (ZipEntry) e.nextElement();
 			String eName= member.getName();
 			if (member.isDirectory()) {
 				eName= eName.substring(0, eName.length() - 1);
 				eName= eName.replace('/', '.');
 				temp= (Vector[]) packageFragToTypes.get(eName);
 				if (temp == null) {
 					temp= new Vector[] { new Vector(), new Vector()
 				 };
 					packageFragToTypes.put(eName, temp);
 				}
 			} else {
 				if (Util.isClassFileName(eName)) {
 					//only interested in class files
 					//store the class file entry name to be cached in the appropriate package fragment
 					//zip entries only use '/'
 					Vector classTemp;
 					int lastSeparator= eName.lastIndexOf('/');
 					String key= IPackageFragment.DEFAULT_PACKAGE_NAME;
 					String value= eName;
 					if (lastSeparator != -1) {
 						//not in the default package
 						eName= eName.replace('/', '.');
 						value= eName.substring(lastSeparator + 1);
 						key= eName.substring(0, lastSeparator);
 					}
 					temp= (Vector[]) packageFragToTypes.get(key);
 					if (temp == null) {
 						// build all package fragments in the key
 						lastSeparator= key.indexOf('.');
 						while (lastSeparator > 0) {
 							String prefix= key.substring(0, lastSeparator);
 							if (packageFragToTypes.get(prefix) == null) {
 								packageFragToTypes.put(prefix, new Vector[] { new Vector(), new Vector()
 							 });
 							}
 							lastSeparator= key.indexOf('.', lastSeparator + 1);
 						}
 						classTemp= new Vector();
 						classTemp.addElement(value);
 						packageFragToTypes.put(key, new Vector[] {classTemp, new Vector()
 					 });
 					} else {
 						classTemp= temp[0];
 						classTemp.addElement(value);
 					}
 				} else {
 					Vector resTemp;
 					int lastSeparator= eName.lastIndexOf('/');
 					String key= IPackageFragment.DEFAULT_PACKAGE_NAME;
 					String value= eName;
 					if (lastSeparator != -1) {
 						//not in the default package
 						eName= eName.replace('/', '.');
 						key= eName.substring(0, lastSeparator);
 					}
 					temp= (Vector[]) packageFragToTypes.get(key);
 					if (temp == null) {
 						// build all package fragments in the key
 						lastSeparator= key.indexOf('.');
 						while (lastSeparator > 0) {
 							String prefix= key.substring(0, lastSeparator);
 							if (packageFragToTypes.get(prefix) == null) {
 								packageFragToTypes.put(prefix, new Vector[] { new Vector(), new Vector()
 							 });
 							}
 							lastSeparator= key.indexOf('.', lastSeparator + 1);
 						}
 						resTemp= new Vector();
 						resTemp.addElement(value);
 						packageFragToTypes.put(key, new Vector[] { new Vector(), resTemp });
 					} else {
 						resTemp= temp[1];
 						resTemp.addElement(value);
 					}
 				}
 			}
 		}
 		//loop through all of referenced packages, creating package fragments if necessary
 		// and cache the entry names in the infos created for those package fragments
 		Enumeration packages= packageFragToTypes.keys();
 		while (packages.hasMoreElements()) {
 			String packName= (String) packages.nextElement();
 			Vector[] entries= (Vector[]) packageFragToTypes.get(packName);
 			JarPackageFragment packFrag= (JarPackageFragment) getPackageFragment(packName);
 			JarPackageFragmentInfo fragInfo= (JarPackageFragmentInfo) packFrag.createElementInfo();
 			fragInfo.setEntryNames(entries[0]);
 			int resLength= entries[1].size();
 			if (resLength == 0) {
 				packFrag.computeNonJavaResources(new String[] {}, fragInfo, jar.getName());
 			} else {
 				String[] resNames= new String[resLength];
 				entries[1].copyInto(resNames);
 				packFrag.computeNonJavaResources(resNames, fragInfo, jar.getName());
 			}
 			packFrag.computeChildren(fragInfo);
 			fgJavaModelManager.putInfo(packFrag, fragInfo);
 			vChildren.addElement(packFrag);
 		}
 	} catch (CoreException e) {
 		throw new JavaModelException(e);
 	} finally {
 		if (jar != null) {
 			try {
 				jar.close();
 			} catch (IOException e) {
 				// ignore
 			}
 		}
 	}
 }
 	/**
 	 * Returns a new element info for this element.
 	 */
 	protected OpenableElementInfo createElementInfo() {
 		return new JarPackageFragmentRootInfo();
 	}
 	/**
 	 * A Jar is always K_BINARY.
 	 *
 	 * @exception NotPresentException if the project and root do
 	 *      not exist.
 	 */
 	protected int determineKind(IResource underlyingResource) throws JavaModelException {
 		return IPackageFragmentRoot.K_BINARY;
 	}
 	/**
 	 * Returns true if this handle represents the same jar
 	 * as the given handle. Two jars are equal if they share
 	 * the same zip file.
 	 *
 	 * @see Object#equals
 	 */
 	public boolean equals(Object o) {
 		if (this == o)
 			return true;
 		if (o instanceof JarPackageFragmentRoot) {
 			JarPackageFragmentRoot other= (JarPackageFragmentRoot) o;
 			return fJarPath.equals(other.fJarPath);
 		}
 		return false;
 	}
 public IClasspathEntry findSourceAttachmentRecommendation() {

 	try {

 		IPath rootPath = this.getPath();
 		IClasspathEntry entry;
 		IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();

 		// try on enclosing project first
 		JavaProject parentProject = (JavaProject) getJavaProject();
 		try {
 			entry = parentProject.getClasspathEntryFor(rootPath);
 			if (entry != null){
 				Object target = JavaModel.getTarget(workspaceRoot, entry.getSourceAttachmentPath(), true);
 				if (target instanceof IFile){
 					IFile file = (IFile) target;
 					if ("jar"/*nonNLS*/.equalsIgnoreCase(file.getFileExtension()) || "zip"/*nonNLS*/.equalsIgnoreCase(file.getFileExtension())){
 						return entry;
 					}
 				}
 				if (target instanceof java.io.File){
 					java.io.File file = (java.io.File) target;
 					String name = file.getName();
 					if (Util.endsWithIgnoreCase(name, ".jar"/*nonNLS*/) || Util.endsWithIgnoreCase(name, ".zip"/*nonNLS*/)){
 						return entry;
 					}
 				}
 			}
 		} catch(JavaModelException e){
 		}

 		// iterate over all projects
 		IJavaModel model = getJavaModel();
 		IJavaProject[] jProjects = model.getJavaProjects();
 		for (int i = 0, max = jProjects.length; i < max; i++){
 			JavaProject jProject = (JavaProject) jProjects[i];
 			if (jProject == parentProject) continue; // already done
 			try {
 				entry = jProject.getClasspathEntryFor(rootPath);
 				if (entry != null){
 					Object target = JavaModel.getTarget(workspaceRoot, entry.getSourceAttachmentPath(), true);
 					if (target instanceof IFile){
 						IFile file = (IFile) target;
 						String name = file.getName();
 						if (Util.endsWithIgnoreCase(name, ".jar"/*nonNLS*/) || Util.endsWithIgnoreCase(name, ".zip"/*nonNLS*/)){
 							return entry;
 						}
 					}
 					if (target instanceof java.io.File){
 						java.io.File file = (java.io.File) target;
 						String name = file.getName();
 						if (Util.endsWithIgnoreCase(name, ".jar"/*nonNLS*/) || Util.endsWithIgnoreCase(name, ".zip"/*nonNLS*/)){
 							return entry;
 						}
 					}
 				}
 			} catch(JavaModelException e){
 			}
 		}
 	} catch(JavaModelException e){
 	}

 	return null;
 }
 	/**
 	 * Returns the underlying ZipFile for this Jar package fragment root.
 	 *
 	 * @exception CoreException if an error occurs accessing the jar
 	 */
 	public ZipFile getJar() throws CoreException {
 		return fgJavaModelManager.getZipFile(getPath());
 	}
 	/**
 	 * @see IJavaElement
 	 */
 	public IJavaProject getJavaProject() {
 		IJavaElement parent= getParent();
 		if (parent == null) {
 			return null;
 		} else {
 			return parent.getJavaProject();
 		}
 	}
 	/**
 	 * @see IPackageFragmentRoot
 	 */
 	public int getKind() {
 		return IPackageFragmentRoot.K_BINARY;
 	}
 	/**
 	 * Returns an array of non-java resources contained in the receiver.
 	 */
 	public Object[] getNonJavaResources() throws JavaModelException {
 		// We want to show non java resources of the default package at the root (see PR #1G58NB8)
 		return ((JarPackageFragment) this.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME)).storedNonJavaResources();
 	}
 	/**
 	 * @see IPackageFragmentRoot
 	 */
 	public IPackageFragment getPackageFragment(String packageName) {

 		return new JarPackageFragment(this, packageName);
 	}
 	/**
 	 * @see IPackageFragmentRoot
 	 */
 	public IPath getPath() {
 		if (fResource == null) {
 			return fJarPath;
 		} else {
 			return super.getPath();
 		}
 	}
 	/**
 	 * @see IPackageFragmentRoot
 	 */
 	public IPath getSourceAttachmentPath() throws JavaModelException {
 		String serverPathString= getSourceAttachmentProperty();
 		if (serverPathString == null) {
 			return null;
 		}
 		int index= serverPathString.lastIndexOf(ATTACHMENT_PROPERTY_DELIMITER);
 		if (index < 0) return null;
 		String serverZipPathString= serverPathString.substring(0, index);
 		return new Path(serverZipPathString);
 	}
 	/**
 	 * Returns the server property for this package fragment root's
 	 * source attachement.
 	 */
 	protected String getSourceAttachmentProperty() throws JavaModelException {
 		String propertyString = null;
 		QualifiedName qName= getSourceAttachmentPropertyName();
 		try {
 			propertyString = getWorkspace().getRoot().getPersistentProperty(qName);

 			// if no existing source attachment information, then lookup a recommendation from classpath entries
 			if (propertyString == null || propertyString.lastIndexOf(ATTACHMENT_PROPERTY_DELIMITER) < 0){
 				IClasspathEntry recommendation = findSourceAttachmentRecommendation();
 				if (recommendation != null){
 					propertyString = recommendation.getSourceAttachmentPath().toString()
 										+ ATTACHMENT_PROPERTY_DELIMITER
 										+ (recommendation.getSourceAttachmentRootPath() == null ? ""/*nonNLS*/ : recommendation.getSourceAttachmentRootPath().toString());
 					getWorkspace().getRoot().setPersistentProperty(qName, propertyString);
 				}
 			}
 			return propertyString;
 		} catch (CoreException ce) {
 			throw new JavaModelException(ce);
 		}
 	}
 	/**
 	 * Returns the qualified name for the source attachment property
 	 * of this jar.
 	 */
 	protected QualifiedName getSourceAttachmentPropertyName() throws JavaModelException {
 		ZipFile jarFile = null;
 		try {
 			jarFile = getJar();
 			return new QualifiedName(JavaCore.PLUGIN_ID, "sourceattachment: "/*nonNLS*/ + jarFile.getName());
 		} catch (CoreException e) {
 			throw new JavaModelException(e);
 		} finally {
 			try {
 				if (jarFile != null) {
 					jarFile.close();
 				}
 			} catch(IOException e) {
 				// ignore
 			}
 		}
 	}
 	/**
 	 * @see IPackageFragmentRoot
 	 */
 	public IPath getSourceAttachmentRootPath() throws JavaModelException {
 		String serverPathString= getSourceAttachmentProperty();
 		if (serverPathString == null) {
 			return null;
 		}
 		int index= serverPathString.lastIndexOf(ATTACHMENT_PROPERTY_DELIMITER);
 		String serverRootPathString= IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH;
 		if (index != serverPathString.length() - 1) {
 			serverRootPathString= serverPathString.substring(index + 1);
 		}
 		return new Path(serverRootPathString);
 	}
 	/**
 	 * @see JavaElement
 	 */
 	public SourceMapper getSourceMapper() {
 		try {
 			return ((JarPackageFragmentRootInfo) getElementInfo()).getSourceMapper();
 		} catch (JavaModelException e) {
 			return null;
 		}
 	}
 	/**
 	 * @see IJavaElement
 	 */
 	public IResource getUnderlyingResource() throws JavaModelException {
 		if (fResource == null) {
 			return null;
 		} else {
 			return super.getUnderlyingResource();
 		}
 	}
 	/**
 	 * If I am not open, return true to avoid parsing.
 	 *
 	 * @see IParent
 	 */
 	public boolean hasChildren() throws JavaModelException {
 		if (isOpen()) {
 			return getChildren().length > 0;
 		} else {
 			return true;
 		}
 	}
 	public int hashCode() {
 		return fJarPath.hashCode();
 	}
 	/**
 	 * @see IPackageFragmentRoot
 	 */
 	public boolean isArchive() {
 		return true;
 	}
 	/**
 	 * @see IPackageFragmentRoot
 	 */
 	public boolean isExternal() {
 		return fResource == null;
 	}
 	/**
 	 * Jars and jar entries are all read only
 	 */
 	public boolean isReadOnly() {
 		return true;
 	}
 	/**
 	 * @see Openable#openWhenClosed()
 	 */
 	protected void openWhenClosed(IProgressMonitor pm) throws JavaModelException {
 		super.openWhenClosed(pm);
 		try {
 			//restore any stored attached source zip
 			IPath zipPath= getSourceAttachmentPath();
 			if (zipPath != null) {
 				IPath rootPath= getSourceAttachmentRootPath();
 				attachSource(zipPath, rootPath, pm);
 			}
 		} catch(JavaModelException e){ // no attached source
 		}
 	}
 	/**
 	 * An archive cannot refresh its children.
 	 */
 	public void refreshChildren() {
 		// do nothing
 	}
 	/**
 	 * Reset the array of non-java resources contained in the receiver to null.
 	 */
 	public void resetNonJavaResources() throws JavaModelException {
 		((JarPackageFragmentRootInfo) getElementInfo()).setNonJavaResources(null);
 	}
 	/**
 	 * @private - for use by <code>AttachSourceOperation</code> only.
 	 * Sets the source mapper associated with this jar.
 	 */
 	public void setSourceMapper(SourceMapper mapper) throws JavaModelException {
 		((JarPackageFragmentRootInfo) getElementInfo()).setSourceMapper(mapper);
 	}
 	/**
 	 * Possible failures: <ul>
 	 *  <li>RELATIVE_PATH - the path supplied to this operation must be
 	 *      an absolute path
 	 *  <li>ELEMENT_NOT_PRESENT - the jar supplied to the operation
 	 *      does not exist
 	 * </ul>
 	 */
 	protected void verifyAttachSource(IPath zipPath) throws JavaModelException {
 		IJavaModelStatus status= null;
 		if (!exists0()) {
 			throw newNotPresentException();
 		} else if (zipPath != null && !zipPath.isAbsolute()) {
 			throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.RELATIVE_PATH, zipPath));
 		}
 	}

 /**
  * @see JavaElement#getHandleMemento()
  */
 public String getHandleMemento(){
 	StringBuffer buff= new StringBuffer(((JavaElement)getParent()).getHandleMemento());
 	buff.append(getHandleMementoDelimiter());
 	buff.append(this.fJarPath.toString()); // 1GEP51U
 	return buff.toString();
 }
 }
	package org.eclipse.jdt.internal.core;

	/*
	* (c) Copyright IBM Corp. 2000, 2001.
	* All Rights Reserved.
	*/
	import org.eclipse.core.runtime.*;
	import org.eclipse.core.resources.*;
	import org.eclipse.jdt.core.*;

	import java.io.*;
	import java.util.*;
	import java.util.zip.*;

	/**
	* A package fragment root that corresponds to a .jar or .zip.
	*
	* <p>NOTE: The only visible entries from a .jar or .zip package fragment root
	* are .class files.
	* <p>NOTE: A jar package fragment root may or may not have an associated resource.
	*
	* @see IPackageFragmentRoot
	* @see JarPackageFragmentRootInfo
	*/
	public class JarPackageFragmentRoot extends PackageFragmentRoot {
	/**
	* The absolute path to the jar file.
	*/
	protected IPath fJarPath= null;

	/**
	* The delimiter between the zip path and source path in the
	* attachment server property.
	*/
	protected final static char ATTACHMENT_PROPERTY_DELIMITER= '*';

	/**
	* The name of the meta-inf directory not to be included as a
	* jar package fragment.
	* @see #computeJarChildren
	*/
	//protected final static String META_INF_NAME = "META-INF/";
	/**
	* Constructs a package fragment root which is the root of the Java package directory hierarchy
	* based on a JAR file that is not contained in a <code>IJavaProject</code> and
	* does not have an associated <code>IResource</code>.
	*/
	protected JarPackageFragmentRoot(String jarPath, IJavaProject project) {
	super(null, project, jarPath);
	fJarPath= new Path(jarPath);
	}
	/**
	* Constructs a package fragment root which is the root of the Java package directory hierarchy
	* based on a JAR file.
	*/
	protected JarPackageFragmentRoot(IResource resource, IJavaProject project) {
	super(resource, project);
	fJarPath= resource.getFullPath();
	}
	/**
	* @see IPackageFragmentRoot
	*/
	public void attachSource(IPath zipPath, IPath rootPath, IProgressMonitor monitor) throws JavaModelException {
	QualifiedName qName= getSourceAttachmentPropertyName();
	try {
	verifyAttachSource(zipPath);
	if (monitor != null) {
	monitor.beginTask(Util.bind("element.attachingSource"/nonNLS/), 2);
	}
	SourceMapper mapper= null;
	SourceMapper oldMapper= getSourceMapper();
	IWorkspace workspace= getJavaModel().getWorkspace();
	boolean rootNeedsToBeClosed= false;

	if (zipPath == null) {
	//source being detached
	rootNeedsToBeClosed= true;
	/* Disable deltas (see 1GDTUSD)
	// fire a delta to notify the UI about the source detachement.
	JavaModelManager manager = (JavaModelManager) JavaModelManager.getJavaModelManager();
	JavaModel model = (JavaModel) getJavaModel();
	JavaElementDelta attachedSourceDelta = new JavaElementDelta(model);
	attachedSourceDelta .sourceDetached(this); // this would be a JarPackageFragmentRoot
	manager.registerResourceDelta(attachedSourceDelta );
	manager.fire(); // maybe you want to fire the change later. Let us know about it.
	*/
	} else {
	/*
	// fire a delta to notify the UI about the source attachement.
	JavaModelManager manager = (JavaModelManager) JavaModelManager.getJavaModelManager();
	JavaModel model = (JavaModel) getJavaModel();
	JavaElementDelta attachedSourceDelta = new JavaElementDelta(model);
	attachedSourceDelta .sourceAttached(this); // this would be a JarPackageFragmentRoot
	manager.registerResourceDelta(attachedSourceDelta );
	manager.fire(); // maybe you want to fire the change later. Let us know about it.
	*/
	String rootPathString= null;
	if (rootPath == null) {
	rootPath= new Path(IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH);
	}

	//check if different from the current attachment
	IPath storedZipPath= getSourceAttachmentPath();
	IPath storedRootPath= getSourceAttachmentRootPath();
	if (monitor != null) {
	monitor.worked(1);
	}
	if (storedZipPath != null) {
	if (!(storedZipPath.equals(zipPath) && rootPath.equals(storedRootPath))) {
	rootNeedsToBeClosed= true;
	}
	}
	if ((zipPath.isAbsolute() && workspace.getRoot().findMember(zipPath) != null) \|\| !zipPath.isAbsolute()) {
	// internal to the workbench
	// a resource
	IResource zipFile= workspace.getRoot().findMember(zipPath);
	if (zipFile == null) {
	if (monitor != null) {
	monitor.done();
	}
	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.INVALID_PATH, zipPath));
	}
	if (!(zipFile.getType() == IResource.FILE)) {
	if (monitor != null) {
	monitor.done();
	}
	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.INVALID_PATH, zipPath));
	}
	}
	mapper= new SourceMapper(zipPath, rootPath.toOSString(), (JavaModel) getJavaModel());
	}
	setSourceMapper(mapper);
	if (zipPath == null) {
	//remove the property
	getWorkspace().getRoot().setPersistentProperty(qName, null);
	} else {
	//set the property to the path of the mapped zip
	getWorkspace().getRoot().setPersistentProperty(qName, zipPath.toString() + ATTACHMENT_PROPERTY_DELIMITER + rootPath.toString());
	}
	if (rootNeedsToBeClosed) {
	if (oldMapper != null) {
	oldMapper.close();
	}
	IBufferManager manager= BufferManager.getDefaultBufferManager();
	Enumeration openBuffers= manager.getOpenBuffers();
	while (openBuffers.hasMoreElements()) {
	IBuffer buffer= (IBuffer) openBuffers.nextElement();
	IOpenable possibleJarMember= buffer.getOwner();
	if (isAncestorOf((IJavaElement) possibleJarMember)) {
	buffer.close();
	}
	}
	if (monitor != null) {
	monitor.worked(1);
	}
	}
	} catch (JavaModelException e) {
	try {
	getWorkspace().getRoot().setPersistentProperty(qName, null); // loose info - will be recomputed
	} catch(CoreException ce){
	}
	throw e;
	} catch (CoreException rae) {
	try {
	getWorkspace().getRoot().setPersistentProperty(qName, null); // loose info - will be recomputed
	} catch(CoreException ce){
	}
	throw new JavaModelException(rae);
	} finally {
	if (monitor != null) {
	monitor.done();
	}
	}
	}
	/**
	* Close the associated JAR file stored in the info of this element. If
	* this jar has an associated ZIP source attachment, close it too.
	*
	* @see IOpenable
	*/
	protected void closing(Object info) throws JavaModelException {
	SourceMapper mapper= getSourceMapper();
	if (mapper != null) {
	mapper.close();
	}
	super.closing(info);
	}
	/**
	* Compute the package fragment children of this package fragment root.
	* These are all of the directory zip entries, and any directories implied
	* by the path of class files contained in the jar of this package fragment root.
	* Has the side effect of opening the package fragment children.
	*/
	protected boolean computeChildren(OpenableElementInfo info) throws JavaModelException {
	Vector vChildren= new Vector();
	computeJarChildren((JarPackageFragmentRootInfo) info, vChildren);
	IJavaElement[] children= new IJavaElement[vChildren.size()];
	vChildren.copyInto(children);
	info.setChildren(children);
	return true;
	}
	/**
	* Determine all of the package fragments associated with this package fragment root.
	* Cache the zip entries for each package fragment in the info for the package fragment.
	* The package fragment children are all opened.
	* Add all of the package fragments to vChildren.
	*
	* @exception JavaModelException The resource (the jar) associated with this package fragment root does not exist
	*/
	protected void computeJarChildren(JarPackageFragmentRootInfo info, Vector vChildren) throws JavaModelException {
	ZipFile jar= null;
	try {
	jar= getJar();
	Hashtable packageFragToTypes= new Hashtable();

	// always create the default package
	packageFragToTypes.put(IPackageFragment.DEFAULT_PACKAGE_NAME, new Vector[] { new Vector(), new Vector()
	});

	Vector[] temp;
	for (Enumeration e= jar.entries(); e.hasMoreElements();) {
	ZipEntry member= (ZipEntry) e.nextElement();
	String eName= member.getName();
	if (member.isDirectory()) {
	eName= eName.substring(0, eName.length() - 1);
	eName= eName.replace('/', '.');
	temp= (Vector[]) packageFragToTypes.get(eName);
	if (temp == null) {
	temp= new Vector[] { new Vector(), new Vector()
	};
	packageFragToTypes.put(eName, temp);
	}
	} else {
	if (Util.isClassFileName(eName)) {
	//only interested in class files
	//store the class file entry name to be cached in the appropriate package fragment
	//zip entries only use '/'
	Vector classTemp;
	int lastSeparator= eName.lastIndexOf('/');
	String key= IPackageFragment.DEFAULT_PACKAGE_NAME;
	String value= eName;
	if (lastSeparator != -1) {
	//not in the default package
	eName= eName.replace('/', '.');
	value= eName.substring(lastSeparator + 1);
	key= eName.substring(0, lastSeparator);
	}
	temp= (Vector[]) packageFragToTypes.get(key);
	if (temp == null) {
	// build all package fragments in the key
	lastSeparator= key.indexOf('.');
	while (lastSeparator > 0) {
	String prefix= key.substring(0, lastSeparator);
	if (packageFragToTypes.get(prefix) == null) {
	packageFragToTypes.put(prefix, new Vector[] { new Vector(), new Vector()
	});
	}
	lastSeparator= key.indexOf('.', lastSeparator + 1);
	}
	classTemp= new Vector();
	classTemp.addElement(value);
	packageFragToTypes.put(key, new Vector[] {classTemp, new Vector()
	});
	} else {
	classTemp= temp[0];
	classTemp.addElement(value);
	}
	} else {
	Vector resTemp;
	int lastSeparator= eName.lastIndexOf('/');
	String key= IPackageFragment.DEFAULT_PACKAGE_NAME;
	String value= eName;
	if (lastSeparator != -1) {
	//not in the default package
	eName= eName.replace('/', '.');
	key= eName.substring(0, lastSeparator);
	}
	temp= (Vector[]) packageFragToTypes.get(key);
	if (temp == null) {
	// build all package fragments in the key
	lastSeparator= key.indexOf('.');
	while (lastSeparator > 0) {
	String prefix= key.substring(0, lastSeparator);
	if (packageFragToTypes.get(prefix) == null) {
	packageFragToTypes.put(prefix, new Vector[] { new Vector(), new Vector()
	});
	}
	lastSeparator= key.indexOf('.', lastSeparator + 1);
	}
	resTemp= new Vector();
	resTemp.addElement(value);
	packageFragToTypes.put(key, new Vector[] { new Vector(), resTemp });
	} else {
	resTemp= temp[1];
	resTemp.addElement(value);
	}
	}
	}
	}
	//loop through all of referenced packages, creating package fragments if necessary
	// and cache the entry names in the infos created for those package fragments
	Enumeration packages= packageFragToTypes.keys();
	while (packages.hasMoreElements()) {
	String packName= (String) packages.nextElement();
	Vector[] entries= (Vector[]) packageFragToTypes.get(packName);
	JarPackageFragment packFrag= (JarPackageFragment) getPackageFragment(packName);
	JarPackageFragmentInfo fragInfo= (JarPackageFragmentInfo) packFrag.createElementInfo();
	fragInfo.setEntryNames(entries[0]);
	int resLength= entries[1].size();
	if (resLength == 0) {
	packFrag.computeNonJavaResources(new String[] {}, fragInfo, jar.getName());
	} else {
	String[] resNames= new String[resLength];
	entries[1].copyInto(resNames);
	packFrag.computeNonJavaResources(resNames, fragInfo, jar.getName());
	}
	packFrag.computeChildren(fragInfo);
	fgJavaModelManager.putInfo(packFrag, fragInfo);
	vChildren.addElement(packFrag);
	}
	} catch (CoreException e) {
	throw new JavaModelException(e);
	} finally {
	if (jar != null) {
	try {
	jar.close();
	} catch (IOException e) {
	// ignore
	}
	}
	}
	}
	/**
	* Returns a new element info for this element.
	*/
	protected OpenableElementInfo createElementInfo() {
	return new JarPackageFragmentRootInfo();
	}
	/**
	* A Jar is always K_BINARY.
	*
	* @exception NotPresentException if the project and root do
	* not exist.
	*/
	protected int determineKind(IResource underlyingResource) throws JavaModelException {
	return IPackageFragmentRoot.K_BINARY;
	}
	/**
	* Returns true if this handle represents the same jar
	* as the given handle. Two jars are equal if they share
	* the same zip file.
	*
	* @see Object#equals
	*/
	public boolean equals(Object o) {
	if (this == o)
	return true;
	if (o instanceof JarPackageFragmentRoot) {
	JarPackageFragmentRoot other= (JarPackageFragmentRoot) o;
	return fJarPath.equals(other.fJarPath);
	}
	return false;
	}
	public IClasspathEntry findSourceAttachmentRecommendation() {

	try {

	IPath rootPath = this.getPath();
	IClasspathEntry entry;
	IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();

	// try on enclosing project first
	JavaProject parentProject = (JavaProject) getJavaProject();
	try {
	entry = parentProject.getClasspathEntryFor(rootPath);
	if (entry != null){
	Object target = JavaModel.getTarget(workspaceRoot, entry.getSourceAttachmentPath(), true);
	if (target instanceof IFile){
	IFile file = (IFile) target;
	if ("jar"/nonNLS/.equalsIgnoreCase(file.getFileExtension()) \|\| "zip"/nonNLS/.equalsIgnoreCase(file.getFileExtension())){
	return entry;
	}
	}
	if (target instanceof java.io.File){
	java.io.File file = (java.io.File) target;
	String name = file.getName();
	if (Util.endsWithIgnoreCase(name, ".jar"/nonNLS/) \|\| Util.endsWithIgnoreCase(name, ".zip"/nonNLS/)){
	return entry;
	}
	}
	}
	} catch(JavaModelException e){
	}

	// iterate over all projects
	IJavaModel model = getJavaModel();
	IJavaProject[] jProjects = model.getJavaProjects();
	for (int i = 0, max = jProjects.length; i < max; i++){
	JavaProject jProject = (JavaProject) jProjects[i];
	if (jProject == parentProject) continue; // already done
	try {
	entry = jProject.getClasspathEntryFor(rootPath);
	if (entry != null){
	Object target = JavaModel.getTarget(workspaceRoot, entry.getSourceAttachmentPath(), true);
	if (target instanceof IFile){
	IFile file = (IFile) target;
	String name = file.getName();
	if (Util.endsWithIgnoreCase(name, ".jar"/nonNLS/) \|\| Util.endsWithIgnoreCase(name, ".zip"/nonNLS/)){
	return entry;
	}
	}
	if (target instanceof java.io.File){
	java.io.File file = (java.io.File) target;
	String name = file.getName();
	if (Util.endsWithIgnoreCase(name, ".jar"/nonNLS/) \|\| Util.endsWithIgnoreCase(name, ".zip"/nonNLS/)){
	return entry;
	}
	}
	}
	} catch(JavaModelException e){
	}
	}
	} catch(JavaModelException e){
	}

	return null;
	}
	/**
	* Returns the underlying ZipFile for this Jar package fragment root.
	*
	* @exception CoreException if an error occurs accessing the jar
	*/
	public ZipFile getJar() throws CoreException {
	return fgJavaModelManager.getZipFile(getPath());
	}
	/**
	* @see IJavaElement
	*/
	public IJavaProject getJavaProject() {
	IJavaElement parent= getParent();
	if (parent == null) {
	return null;
	} else {
	return parent.getJavaProject();
	}
	}
	/**
	* @see IPackageFragmentRoot
	*/
	public int getKind() {
	return IPackageFragmentRoot.K_BINARY;
	}
	/**
	* Returns an array of non-java resources contained in the receiver.
	*/
	public Object[] getNonJavaResources() throws JavaModelException {
	// We want to show non java resources of the default package at the root (see PR #1G58NB8)
	return ((JarPackageFragment) this.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME)).storedNonJavaResources();
	}
	/**
	* @see IPackageFragmentRoot
	*/
	public IPackageFragment getPackageFragment(String packageName) {

	return new JarPackageFragment(this, packageName);
	}
	/**
	* @see IPackageFragmentRoot
	*/
	public IPath getPath() {
	if (fResource == null) {
	return fJarPath;
	} else {
	return super.getPath();
	}
	}
	/**
	* @see IPackageFragmentRoot
	*/
	public IPath getSourceAttachmentPath() throws JavaModelException {
	String serverPathString= getSourceAttachmentProperty();
	if (serverPathString == null) {
	return null;
	}
	int index= serverPathString.lastIndexOf(ATTACHMENT_PROPERTY_DELIMITER);
	if (index < 0) return null;
	String serverZipPathString= serverPathString.substring(0, index);
	return new Path(serverZipPathString);
	}
	/**
	* Returns the server property for this package fragment root's
	* source attachement.
	*/
	protected String getSourceAttachmentProperty() throws JavaModelException {
	String propertyString = null;
	QualifiedName qName= getSourceAttachmentPropertyName();
	try {
	propertyString = getWorkspace().getRoot().getPersistentProperty(qName);

	// if no existing source attachment information, then lookup a recommendation from classpath entries
	if (propertyString == null \|\| propertyString.lastIndexOf(ATTACHMENT_PROPERTY_DELIMITER) < 0){
	IClasspathEntry recommendation = findSourceAttachmentRecommendation();
	if (recommendation != null){
	propertyString = recommendation.getSourceAttachmentPath().toString()
	+ ATTACHMENT_PROPERTY_DELIMITER
	+ (recommendation.getSourceAttachmentRootPath() == null ? ""/nonNLS/ : recommendation.getSourceAttachmentRootPath().toString());
	getWorkspace().getRoot().setPersistentProperty(qName, propertyString);
	}
	}
	return propertyString;
	} catch (CoreException ce) {
	throw new JavaModelException(ce);
	}
	}
	/**
	* Returns the qualified name for the source attachment property
	* of this jar.
	*/
	protected QualifiedName getSourceAttachmentPropertyName() throws JavaModelException {
	ZipFile jarFile = null;
	try {
	jarFile = getJar();
	return new QualifiedName(JavaCore.PLUGIN_ID, "sourceattachment: "/nonNLS/ + jarFile.getName());
	} catch (CoreException e) {
	throw new JavaModelException(e);
	} finally {
	try {
	if (jarFile != null) {
	jarFile.close();
	}
	} catch(IOException e) {
	// ignore
	}
	}
	}
	/**
	* @see IPackageFragmentRoot
	*/
	public IPath getSourceAttachmentRootPath() throws JavaModelException {
	String serverPathString= getSourceAttachmentProperty();
	if (serverPathString == null) {
	return null;
	}
	int index= serverPathString.lastIndexOf(ATTACHMENT_PROPERTY_DELIMITER);
	String serverRootPathString= IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH;
	if (index != serverPathString.length() - 1) {
	serverRootPathString= serverPathString.substring(index + 1);
	}
	return new Path(serverRootPathString);
	}
	/**
	* @see JavaElement
	*/
	public SourceMapper getSourceMapper() {
	try {
	return ((JarPackageFragmentRootInfo) getElementInfo()).getSourceMapper();
	} catch (JavaModelException e) {
	return null;
	}
	}
	/**
	* @see IJavaElement
	*/
	public IResource getUnderlyingResource() throws JavaModelException {
	if (fResource == null) {
	return null;
	} else {
	return super.getUnderlyingResource();
	}
	}
	/**
	* If I am not open, return true to avoid parsing.
	*
	* @see IParent
	*/
	public boolean hasChildren() throws JavaModelException {
	if (isOpen()) {
	return getChildren().length > 0;
	} else {
	return true;
	}
	}
	public int hashCode() {
	return fJarPath.hashCode();
	}
	/**
	* @see IPackageFragmentRoot
	*/
	public boolean isArchive() {
	return true;
	}
	/**
	* @see IPackageFragmentRoot
	*/
	public boolean isExternal() {
	return fResource == null;
	}
	/**
	* Jars and jar entries are all read only
	*/
	public boolean isReadOnly() {
	return true;
	}
	/**
	* @see Openable#openWhenClosed()
	*/
	protected void openWhenClosed(IProgressMonitor pm) throws JavaModelException {
	super.openWhenClosed(pm);
	try {
	//restore any stored attached source zip
	IPath zipPath= getSourceAttachmentPath();
	if (zipPath != null) {
	IPath rootPath= getSourceAttachmentRootPath();
	attachSource(zipPath, rootPath, pm);
	}
	} catch(JavaModelException e){ // no attached source
	}
	}
	/**
	* An archive cannot refresh its children.
	*/
	public void refreshChildren() {
	// do nothing
	}
	/**
	* Reset the array of non-java resources contained in the receiver to null.
	*/
	public void resetNonJavaResources() throws JavaModelException {
	((JarPackageFragmentRootInfo) getElementInfo()).setNonJavaResources(null);
	}
	/**
	* @private - for use by <code>AttachSourceOperation</code> only.
	* Sets the source mapper associated with this jar.
	*/
	public void setSourceMapper(SourceMapper mapper) throws JavaModelException {
	((JarPackageFragmentRootInfo) getElementInfo()).setSourceMapper(mapper);
	}
	/**
	* Possible failures: <ul>
	* <li>RELATIVE_PATH - the path supplied to this operation must be
	* an absolute path
	* <li>ELEMENT_NOT_PRESENT - the jar supplied to the operation
	* does not exist
	* </ul>
	*/
	protected void verifyAttachSource(IPath zipPath) throws JavaModelException {
	IJavaModelStatus status= null;
	if (!exists0()) {
	throw newNotPresentException();
	} else if (zipPath != null && !zipPath.isAbsolute()) {
	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.RELATIVE_PATH, zipPath));
	}
	}

	/**
	* @see JavaElement#getHandleMemento()
	*/
	public String getHandleMemento(){
	StringBuffer buff= new StringBuffer(((JavaElement)getParent()).getHandleMemento());
	buff.append(getHandleMementoDelimiter());
	buff.append(this.fJarPath.toString()); // 1GEP51U
	return buff.toString();
	}
	}