/projects/aspectj-1.6.9/aspectjtools1.6.9/org/aspectj/org/eclipse/jdt/internal/core/JarPackageFragmentRoot.java

/*******************************************************************************

 * Copyright (c) 2000, 2007 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.aspectj.org.eclipse.jdt.internal.core;



import java.util.*;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;



import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.aspectj.org.eclipse.jdt.core.*;

import org.aspectj.org.eclipse.jdt.core.compiler.CharOperation;

import org.aspectj.org.eclipse.jdt.internal.core.util.HashtableOfArrayToObject;

import org.aspectj.org.eclipse.jdt.internal.core.util.Util;



/**

 * 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 org.aspectj.org.eclipse.jdt.core.IPackageFragmentRoot

 * @see org.aspectj.org.eclipse.jdt.internal.core.JarPackageFragmentRootInfo

 */

public class JarPackageFragmentRoot extends PackageFragmentRoot {

	

	public final static ArrayList EMPTY_LIST = new ArrayList();

	

	/**

	 * The path to the jar file

	 * (a workspace relative path if the jar is internal,

	 * or an OS path if the jar is external)

	 */

	protected final IPath jarPath;



	/**

	 * 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(IPath jarPath, JavaProject project) {

		super(null, project);

		this.jarPath = 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, JavaProject project) {

		super(resource, project);

		this.jarPath = resource.getFullPath();

	}



	/**

	 * 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, Map newElements) throws JavaModelException {

		

		ArrayList vChildren= new ArrayList();

		final int JAVA = 0;

		final int NON_JAVA = 1;

		ZipFile jar= null;

		try {

			jar= getJar();

	

			HashtableOfArrayToObject packageFragToTypes= new HashtableOfArrayToObject();

	

			// always create the default package

			packageFragToTypes.put(CharOperation.NO_STRINGS, new ArrayList[] { EMPTY_LIST, EMPTY_LIST });

	

			for (Enumeration e= jar.entries(); e.hasMoreElements();) {

				ZipEntry member= (ZipEntry) e.nextElement();

				initPackageFragToTypes(packageFragToTypes, member.getName(), member.isDirectory());

			}

			

			//loop through all of referenced packages, creating package fragments if necessary

			// and cache the entry names in the infos created for those package fragments

			for (int i = 0, length = packageFragToTypes.keyTable.length; i < length; i++) {

				String[] pkgName = (String[]) packageFragToTypes.keyTable[i];

				if (pkgName == null) continue;

				

				ArrayList[] entries= (ArrayList[]) packageFragToTypes.get(pkgName);

				JarPackageFragment packFrag= (JarPackageFragment) getPackageFragment(pkgName);

				JarPackageFragmentInfo fragInfo= new JarPackageFragmentInfo();

				int resLength= entries[NON_JAVA].size();

				if (resLength == 0) {

					packFrag.computeNonJavaResources(CharOperation.NO_STRINGS, packFrag, fragInfo, jar.getName());

				} else {

					String[] resNames= new String[resLength];

					entries[NON_JAVA].toArray(resNames);

					packFrag.computeNonJavaResources(resNames, packFrag, fragInfo, jar.getName());

				}

				packFrag.computeChildren(fragInfo, entries[JAVA]);

				newElements.put(packFrag, fragInfo);

				vChildren.add(packFrag);

			}

		} catch (CoreException e) {

			if (e instanceof JavaModelException) throw (JavaModelException)e;

			throw new JavaModelException(e);

		} finally {

			JavaModelManager.getJavaModelManager().closeZipFile(jar);

		}





		IJavaElement[] children= new IJavaElement[vChildren.size()];

		vChildren.toArray(children);

		info.setChildren(children);

		return true;

	}

	/**

	 * Returns a new element info for this element.

	 */

	protected Object createElementInfo() {

		return new JarPackageFragmentRootInfo();

	}

	/**

	 * A Jar is always K_BINARY.

	 */

	protected int determineKind(IResource underlyingResource) {

		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 this.jarPath.equals(other.jarPath);

		}

		return false;

	}

	public String getElementName() {

		return this.jarPath.lastSegment();

	}

	/**

	 * 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 JavaModelManager.getJavaModelManager().getZipFile(getPath());

	}

	/**

	 * @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)

		Object[] defaultPkgResources =  ((JarPackageFragment) getPackageFragment(CharOperation.NO_STRINGS)).storedNonJavaResources();

		int length = defaultPkgResources.length;

		if (length == 0)

			return defaultPkgResources;

		Object[] nonJavaResources = new Object[length];

		for (int i = 0; i < length; i++) {

			JarEntryResource nonJavaResource = (JarEntryResource) defaultPkgResources[i];

			nonJavaResources[i] = nonJavaResource.clone(this);

		}

		return nonJavaResources;

	}

	public PackageFragment getPackageFragment(String[] pkgName) {

		return new JarPackageFragment(this, pkgName);

	}

	/**

	 * @see IPackageFragmentRoot

	 */

	public IPath getPath() {

		if (isExternal()) {

			return this.jarPath;

		} else {

			return super.getPath();

		}

	}

	public IResource getResource() {

		if (this.resource == null) {

			this.resource = JavaModel.getTarget(ResourcesPlugin.getWorkspace().getRoot(), this.jarPath, false);

		}

		if (this.resource instanceof IResource) {

			return super.getResource();

		} else {

			// external jar

			return null;

		}

	}





	/**

	 * @see IJavaElement

	 */

	public IResource getUnderlyingResource() throws JavaModelException {

		if (isExternal()) {

			if (!exists()) throw newNotPresentException();

			return null;

		} else {

			return super.getUnderlyingResource();

		}

	}

	public int hashCode() {

		return this.jarPath.hashCode();

	}

	private void initPackageFragToTypes(HashtableOfArrayToObject packageFragToTypes, String entryName, boolean isDirectory) {

		int lastSeparator = isDirectory ? entryName.length()-1 : entryName.lastIndexOf('/');

		String[] pkgName = Util.splitOn('/', entryName, 0, lastSeparator);

		String[] existing = null;

		int length = pkgName.length;

		int existingLength = length;

		while (existingLength >= 0) {

			existing = (String[]) packageFragToTypes.getKey(pkgName, existingLength);

			if (existing != null) break;

			existingLength--;

		}

		JavaModelManager manager = JavaModelManager.getJavaModelManager();

		IJavaProject project = getJavaProject();

		for (int i = existingLength; i < length; i++) {

			if (Util.isValidFolderNameForPackage(pkgName[i], project.getOption(JavaCore.COMPILER_SOURCE, true), project.getOption(JavaCore.COMPILER_COMPLIANCE, true))) {

				System.arraycopy(existing, 0, existing = new String[i+1], 0, i);

				existing[i] = manager.intern(pkgName[i]);

				packageFragToTypes.put(existing, new ArrayList[] { EMPTY_LIST, EMPTY_LIST });

			} else {

				// non-Java resource folder

				if (!isDirectory) {

					ArrayList[] children = (ArrayList[]) packageFragToTypes.get(existing);

					if (children[1/*NON_JAVA*/] == EMPTY_LIST) children[1/*NON_JAVA*/] = new ArrayList();

					children[1/*NON_JAVA*/].add(entryName);

				}

				return;

			}

		}

		if (isDirectory)

			return;

		

		// add classfile info amongst children

		ArrayList[] children = (ArrayList[]) packageFragToTypes.get(pkgName);

		if (org.aspectj.org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(entryName)) {

			if (children[0/*JAVA*/] == EMPTY_LIST) children[0/*JAVA*/] = new ArrayList();

			String fileName = entryName.substring(lastSeparator + 1);

			children[0/*JAVA*/].add(fileName);

		} else {

			if (children[1/*NON_JAVA*/] == EMPTY_LIST) children[1/*NON_JAVA*/] = new ArrayList();

			children[1/*NON_JAVA*/].add(entryName);

		}

		

	}

	/**

	 * @see IPackageFragmentRoot

	 */

	public boolean isArchive() {

		return true;

	}

	/**

	 * @see IPackageFragmentRoot

	 */

	public boolean isExternal() {

		return getResource() == null;

	}

	/**

	 * Jars and jar entries are all read only

	 */

	public boolean isReadOnly() {

		return true;

	}



	/**

 * Returns whether the corresponding resource or associated file exists

 */

protected boolean resourceExists() {

	if (this.isExternal()) {

		return 

			JavaModel.getTarget(

				ResourcesPlugin.getWorkspace().getRoot(), 

				this.getPath(), // don't make the path relative as this is an external archive

				true) != null;

	} else {

		return super.resourceExists();

	}

}

protected void toStringAncestors(StringBuffer buffer) {

	if (isExternal())

		// don't show project as it is irrelevant for external jar files.

		// also see https://bugs.eclipse.org/bugs/show_bug.cgi?id=146615

		return;

	super.toStringAncestors(buffer);

}

}