/*******************************************************************************
 * Copyright (c) 2001, 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.eclipse.jst.j2ee.commonarchivecore.internal.impl;


import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.WrappedException;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.jem.internal.java.adapters.ReadAdaptor;
import org.eclipse.jem.internal.java.adapters.jdk.JavaJDKAdapterFactory;
import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive;
import org.eclipse.jst.j2ee.commonarchivecore.internal.ArchiveTypeDiscriminatorRegistry;
import org.eclipse.jst.j2ee.commonarchivecore.internal.CommonArchiveResourceHandler;
import org.eclipse.jst.j2ee.commonarchivecore.internal.CommonarchivePackage;
import org.eclipse.jst.j2ee.commonarchivecore.internal.Container;
import org.eclipse.jst.j2ee.commonarchivecore.internal.EARFile;
import org.eclipse.jst.j2ee.commonarchivecore.internal.File;
import org.eclipse.jst.j2ee.commonarchivecore.internal.ReadOnlyDirectory;
import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.DuplicateObjectException;
import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.ManifestException;
import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.OpenFailureException;
import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.ReopenException;
import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.ResourceLoadException;
import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.SaveFailureException;
import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifest;
import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifestImpl;
import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveOptions;
import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.RuntimeClasspathEntry;
import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.RuntimeClasspathEntryImpl;
import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.SaveFilter;
import org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.DirectorySaveStrategyImpl;
import org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.LoadStrategy;
import org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.SaveStrategy;
import org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.ZipStreamSaveStrategyImpl;
import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveFileDynamicClassLoader;
import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveUtil;
import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ClasspathUtil;
import org.eclipse.jst.j2ee.commonarchivecore.looseconfig.internal.LooseArchive;
import org.eclipse.jst.j2ee.internal.J2EEConstants;
import org.eclipse.wst.common.internal.emf.utilities.EtoolsCopyUtility;
import org.eclipse.wst.common.internal.emf.utilities.ExtendedEcoreUtil;


/**
 * @generated
 */
public class ArchiveImpl extends ContainerImpl implements Archive {

	/**
	 * The cached value of the '{@link #getTypes() <em>Types</em>}' attribute list. <!--
	 * begin-user-doc --> <!-- end-user-doc -->
	 * 
	 * @see #getTypes()
	 * @generated
	 * @ordered
	 */
	protected EList types = null;

	/** Our specialized manifest */
	protected ArchiveManifest manifest;

	/** Implementer for saving this archive */
	protected SaveStrategy saveStrategy;

	/**
	 * Optional filter for saving a subset of files; filter will be applied for all save and extract
	 * invokations
	 */
	protected SaveFilter saveFilter;

	/** Encoding to be used for all xmi resources and xml dds; defaults to UTF-8 */
	protected String xmlEncoding = J2EEConstants.DEFAULT_XML_ENCODING;

	/** Custom class loader used to load classes from the archive */
	protected ClassLoader archiveClassLoader;

	/**
	 * path of the standard classpath format where the archive may look for classes not found in the
	 * system classpath or in the archive - used for java reflection
	 */
	protected String extraClasspath;

	protected ArchiveOptions options;

	public ArchiveImpl() {
		super();
		getCommonArchiveFactory().archiveOpened(this);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 * @generated
	 */
	protected EClass eStaticClass() {
		return CommonarchivePackage.Literals.ARCHIVE;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 * @generated
	 */
	public EList getTypes() {
		if (types == null) {
			types = new EDataTypeUniqueEList(String.class, this, CommonarchivePackage.ARCHIVE__TYPES);
		}
		return types;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case CommonarchivePackage.ARCHIVE__TYPES:
				return getTypes();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
			case CommonarchivePackage.ARCHIVE__TYPES:
				getTypes().clear();
				getTypes().addAll((Collection)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void eUnset(int featureID) {
		switch (featureID) {
			case CommonarchivePackage.ARCHIVE__TYPES:
				getTypes().clear();
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case CommonarchivePackage.ARCHIVE__TYPES:
				return types != null && !types.isEmpty();
		}
		return super.eIsSet(featureID);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 * @generated
	 */
	public String toString() {
		if (eIsProxy()) return super.toString();

		StringBuffer result = new StringBuffer(super.toString());
		result.append(" (types: ");
		result.append(types);
		result.append(')');
		return result.toString();
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public Archive addCopy(Archive anArchive) throws org.eclipse.jst.j2ee.commonarchivecore.internal.exception.DuplicateObjectException {
		checkAddValid(anArchive);
		Archive copy = getCommonArchiveFactory().copy(anArchive);
		getFiles().add(copy);
		return copy;
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive Adds a copy of the parameter to this archive
	 * @throws com.ibm.etools.archive.exception.DuplicateObjectException
	 *             if the archive already contains a file with the specified uri
	 */
	public File addCopy(File aFile) throws DuplicateObjectException {
		if (aFile.isReadOnlyDirectory()) {
			addCopy((ReadOnlyDirectory) aFile);
			return null;
		}
		checkAddValid(aFile);
		File copy = copy(aFile);
		getFiles().add(copy);
		return copy;
	}

	/**
	 * Get a flattened list from the directory, then addCopy the list
	 * 
	 * @throws com.ibm.etools.archive.exception.DuplicateObjectException
	 *             if a file with a uri that equals one of the nested files in the directory exists
	 * 
	 * @return java.util.List the copied files that were added to the archive
	 */
	public java.util.List addCopy(ReadOnlyDirectory dir) throws org.eclipse.jst.j2ee.commonarchivecore.internal.exception.DuplicateObjectException {
		return addCopyFiles(dir.getFilesRecursive());
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public List addCopyFiles(java.util.List list) throws org.eclipse.jst.j2ee.commonarchivecore.internal.exception.DuplicateObjectException {
		//Optimization - make sure the fileIndex is already built to speed up
		// containsFile
		getFiles();
		List copyList = new ArrayList();
		for (int i = 0; i < list.size(); i++) {
			File aFile = (File) list.get(i);
			checkAddValid(aFile);
			copyList.add(copy(aFile));
		}
		getFiles().addAll(copyList);
		return copyList;
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void addOrReplaceMofResource(org.eclipse.emf.ecore.resource.Resource aResource) {
		getLoadStrategy().addOrReplaceMofResource(aResource);
	}

	/**
	 * @deprecated Use {@link #getDependentOpenArchives()}
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public boolean canClose() {
		return !getCommonArchiveFactory().getOpenArchivesDependingOn(this).isEmpty();
	}

	protected void checkAddValid(File aFile) throws DuplicateObjectException {
		checkAddValid(aFile.getURI());
	}

	protected void checkAddValid(String aUri) throws DuplicateObjectException {
		try {
			File f = getFile(aUri);
			if (f != null)
				throw new DuplicateObjectException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.duplicate_file_EXC_, (new Object[]{getURI(), aUri})), f); // = "The archive named {0} already contains a file named {1}"
		} catch (FileNotFoundException ok) {
			//Ignore
		}
	}

	protected void cleanupAfterTempSave(String aUri, java.io.File original, java.io.File destinationFile) throws SaveFailureException {

		checkWriteable(original);
		boolean deleteWorked = false;
		if (original.isDirectory() && !isRenameable(original)) {
			throw new SaveFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.unable_replace_EXC_, (new Object[]{original.getAbsolutePath()}))); // = "Unable to replace original archive "
		}

		for (int i = 0; i < 10; i++) {
			if (ArchiveUtil.delete(original)) {
				deleteWorked = true;
				break;
			}
			try {
				// TODO Major hack here; the problem is that a previous call
				// to close the source file may not yet have
				//been reflected in the os/vm; therefore a subsequent call
				// to delete fails. To get around this,
				//wait for a bit and retry; if it continues to fail, then
				// time out and throw an exception
				Thread.sleep(250);
			} catch (InterruptedException e) {
				//Ignore
			}
		}
		if (deleteWorked) {
			for (int i = 0; i < 10; i++) {
				if (destinationFile.renameTo(original))
					return;
				try {
					Thread.sleep(250);
				} catch (InterruptedException e) {
					//Ignore
				}
			}
		}
		throw new SaveFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.unable_replace_EXC_, (new Object[]{original.getAbsolutePath()}))); // = "Unable to replace original archive "
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void close() {
		getLoadStrategy().close();
		releaseClassLoader();
		getCommonArchiveFactory().archiveClosed(this);
		if (isIndexed()) {
			List archives = getArchiveFiles();
			for (int i = 0; i < archives.size(); i++) {
				((Archive) archives.get(i)).close();
			}
		}
	}

	protected File copy(File aFile) {
		File copy = null;
		if (aFile.isArchive())
			copy = getCommonArchiveFactory().copy((Archive) aFile);
		else
			copy = (File) EtoolsCopyUtility.createCopy(aFile);
		return copy;
	}

	protected LoadStrategy createLoadStrategyForReopen(Archive parent) throws IOException {
		LoadStrategy aLoadStrategy = null;
		LooseArchive loose = getLoadStrategy().getLooseArchive();

		if (loose != null) {
			aLoadStrategy = getCommonArchiveFactory().createLoadStrategy(loose.getBinariesPath());
			aLoadStrategy.setLooseArchive(loose);
		} else if (parent == null)
			aLoadStrategy = getCommonArchiveFactory().createLoadStrategy(getURI());
		else
			aLoadStrategy = getCommonArchiveFactory().createChildLoadStrategy(getURI(), parent.getLoadStrategy());

		return aLoadStrategy;
	}

	protected RuntimeClasspathEntry createRuntimeClasspathEntry(String absolutePath) {
		RuntimeClasspathEntry entry = new RuntimeClasspathEntryImpl();
		entry.setAbsolutePath(absolutePath);
		return entry;
	}

	/**
	 * Convert all the classpath entries to absolute paths
	 */
	protected List createRuntimeClasspathEntries(String[] entries, String parentPath) {

		List aList = new ArrayList(entries.length);
		for (int i = 0; i < entries.length; i++) {
			String entry = entries[i];
			/*
			 * Added for loose module support - if the cananonicalized entry resolves to an archive
			 * in the containing ear, then add the absolute path of that archive
			 */
			Archive dependentJar = resolveClasspathEntryInEAR(entry);
			if (dependentJar != null) {
				try {
					RuntimeClasspathEntry runEntry = createRuntimeClasspathEntry(dependentJar.getBinariesPath(), entry);
					runEntry.setReferencedArchive(dependentJar);
					aList.add(runEntry);
					continue;
				} catch (FileNotFoundException shouldntHappenInRuntime) {
					//Ignore
				}
			}
			//Otherwise, compute the absolute path of the entry relative to
			// this jar
			java.io.File aFile = new java.io.File(entry);
			String absPath = null;
			if (aFile.isAbsolute())
				absPath = aFile.getAbsolutePath();
			else {
				absPath = ArchiveUtil.getOSUri(parentPath, entry);
				absPath = ClasspathUtil.normalizePath(absPath);
			}
			aList.add(createRuntimeClasspathEntry(absPath, entry));
		}

		return aList;
	}

	protected RuntimeClasspathEntry createRuntimeClasspathEntry(String absolutePath, String manifestValue) {
		RuntimeClasspathEntry entry = createRuntimeClasspathEntry(absolutePath);
		entry.setManifestValue(manifestValue);
		return entry;
	}

	protected SaveStrategy createSaveStrategyForDirectory(java.io.File dir, int expansionFlags) {
		return new DirectorySaveStrategyImpl(dir.getAbsolutePath(), expansionFlags);
	}

	protected SaveStrategy createSaveStrategyForDirectory(String aUri, int expansionFlags) {
		return new DirectorySaveStrategyImpl(aUri, expansionFlags);
	}

	protected SaveStrategy createSaveStrategyForJar(java.io.File aFile) throws java.io.IOException {
		if (aFile.exists() && aFile.isDirectory())
			throw new IOException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.file_exist_as_dir_EXC_, (new Object[]{aFile.getAbsolutePath()})));// = "A file named {0} exists and is a directory"
		java.io.File parent = aFile.getParentFile();
		if (parent != null)
			parent.mkdirs();
		java.io.OutputStream out = new java.io.FileOutputStream(aFile);
		return new ZipStreamSaveStrategyImpl(out);
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void extract(int expansionFlags) throws SaveFailureException, ReopenException {
		extractNoReopen(expansionFlags);
		reopen();
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void extractNoReopen(int expansionFlags) throws SaveFailureException {
		String aUri = getURI();
		java.io.File aDir = new java.io.File(aUri);
		boolean inUse = getLoadStrategy().isUsing(aDir);

		try {
			java.io.File destinationDir = inUse ? ArchiveUtil.createTempDirectory(aUri, aDir.getCanonicalFile().getParentFile()) : aDir;
			SaveStrategy aSaveStrategy = createSaveStrategyForDirectory(destinationDir, expansionFlags);
			save(aSaveStrategy);
			aSaveStrategy.close();
			close();
			if (inUse) {
				cleanupAfterTempSave(aUri, aDir, destinationDir);
			}
		} catch (java.io.IOException ex) {
			throw new SaveFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.error_saving_EXC_, (new Object[]{uri})), ex); // = "Error saving "
		}
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void extractTo(java.lang.String aUri, int expansionFlags) throws SaveFailureException {
		java.io.File aDir = new java.io.File(aUri);
		if (getLoadStrategy().isUsing(aDir))
			throw new SaveFailureException(CommonArchiveResourceHandler.Extract_destination_is_the_EXC_); // = "Extract destination is the same path as source file"

		try {
			SaveStrategy aSaveStrategy = createSaveStrategyForDirectory(aDir, expansionFlags);
			save(aSaveStrategy);
			aSaveStrategy.close();
		} catch (java.io.IOException ex) {
			throw new SaveFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.error_saving_EXC_, (new Object[]{aUri})), ex); // = "Error saving "
		}

	}

	public java.util.List filterFilesByPrefix(String prefix) {
		return filterFiles(prefix, null);
	}

	public java.util.List filterFiles(String prefix, String[] suffixes) {
		List subset = new ArrayList();
		List theFiles = getFiles();
		for (int i = 0; i < theFiles.size(); i++) {
			File aFile = (File) theFiles.get(i);
			if (!aFile.isDirectoryEntry() && aFile.getURI().startsWith(prefix))
				if (suffixes == null || hasSuffix(aFile.getURI(), suffixes))
					subset.add(aFile);
		}
		return subset;
	}

	/**
	 * @param uri
	 * @param suffixes
	 * @return
	 */
	private boolean hasSuffix(String aUri, String[] suffixes) {
		for (int i = 0; i < suffixes.length; i++) {
			if (aUri.endsWith(suffixes[i]))
				return true;
		}
		return false;
	}

	public java.util.List filterFilesWithoutPrefix(String[] prefixes) {
		List subset = new ArrayList();
		List theFiles = getFiles();
		for (int i = 0; i < theFiles.size(); i++) {
			File aFile = (File) theFiles.get(i);
			if (aFile.isDirectoryEntry())
				continue;
			boolean shouldAdd = true;
			for (int j = 0; j < prefixes.length; j++) {
				if (aFile.getURI().startsWith(prefixes[j])) {
					shouldAdd = false;
					break;
				}
			}
			if (shouldAdd)
				subset.add(aFile);
		}
		return subset;
	}

	/**
	 * Insert the method's description here. Creation date: (11/29/00 6:35:08 PM)
	 * 
	 * @return java.lang.ClassLoader
	 */
	public java.lang.ClassLoader getArchiveClassLoader() {
		if (archiveClassLoader == null)
			initializeClassLoader();
		return archiveClassLoader;
	}

	/**
	 * @see com.ibm.etools.commonarchive.EARFile
	 */
	public java.util.List getArchiveFiles() {
		List archives = new ArrayList();
		List fileList = getFiles();
		for (int i = 0; i < fileList.size(); i++) {
			File aFile = (File) fileList.get(i);
			if (aFile.isArchive()) {
				archives.add(aFile);
			}
		}
		return archives;
	}

	/**
	 * Parse the manifest class path and the extra class path, and instantiate a URL classloader,
	 * with a parent of the archiveClassLoader
	 */
	protected ClassLoader getClassPathClassLoader(ClassLoader parentCl) {

		List classPathComponents = new ArrayList();
		if (getManifest() != null)
			classPathComponents.addAll(Arrays.asList(getManifest().getClassPathTokenized()));
		String extraCp = getExtraClasspath();
		if (extraCp != null)
			classPathComponents.addAll(Arrays.asList(ArchiveUtil.getTokens(extraCp, ";")));//$NON-NLS-1$

		java.net.URL[] urlArray = ArchiveUtil.toLocalURLs(classPathComponents, getRootForRelativeDependentJars());
		return new java.net.URLClassLoader(urlArray, parentCl);
	}

	public ResourceSet getResourceSet() {
		return getLoadStrategy().getResourceSet();
	}

	/**
	 * Helper method to determine the parent for the custom class loader used by this archive
	 */
	protected ClassLoader getDefaultClassLoader() {
		ClassLoader pluginClassLoader = getClass().getClassLoader();
		return pluginClassLoader == null ? ClassLoader.getSystemClassLoader() : pluginClassLoader;
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public java.util.Set getDependentOpenArchives() {
		return getCommonArchiveFactory().getOpenArchivesDependingOn(this);
	}

	/**
	 * Convert all the classpath entries to absolute paths
	 */
	protected List getEntriesAsAbsolutePaths(String[] entries, String parentPath) {

		List aList = new ArrayList(entries.length);
		for (int i = 0; i < entries.length; i++) {
			String entry = entries[i];
			/*
			 * Added for loose module support - if the cananonicalized entry resolves to an archive
			 * in the containing ear, then add the absolute path of that archive
			 */
			Archive dependentJar = resolveClasspathEntryInEAR(entry);
			if (dependentJar != null) {
				try {
					aList.add(dependentJar.getAbsolutePath());
					continue;
				} catch (FileNotFoundException shouldntHappenInRuntime) {
					//Ignore
				}
			}
			//Otherwise, compute the absolute path of the entry relative to
			// this jar
			java.io.File aFile = new java.io.File(entry);
			if (aFile.isAbsolute())
				aList.add(aFile.getAbsolutePath());
			else
				aList.add(ArchiveUtil.getOSUri(parentPath, entry));
		}

		return aList;
	}

	/**
	 * Insert the method's description here. Creation date: (11/29/00 6:35:08 PM)
	 * 
	 * @return java.lang.String
	 */
	public String getExtraClasspath() {
		return extraClasspath;
	}

	/**
	 * Used internally by the framework, specifically as an optimization when saving/exploding
	 * archives with nested archives
	 */
	public org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.FileIterator getFilesForSave() throws IOException {
		return getLoadStrategy().getFileIterator();
	}

	/**
	 * @see com.ibm.etools.commonarchive.File
	 */
	public java.io.InputStream getInputStream() throws java.io.FileNotFoundException, java.io.IOException {
		if (getLoadingContainer() != null || getLoadStrategy() == null || getLoadStrategy().isDirectory())
			return super.getInputStream();

		//This archive was copied in; this operation is not supported for
		// module files
		if (isModuleFile() || !getOptions().isSaveLibrariesAsFiles())
			throw new IOException("Undefined state of nested archive"); //$NON-NLS-1$

		//We have to find the absolute path of the original archive from which
		// this was copied,
		//if it is known

		List list = getFiles();

		String absolutePath = null;
		for (int i = 0; i < list.size(); i++) {
			File aFile = (File) list.get(i);
			if (aFile.isArchive())
				continue;
			absolutePath = aFile.getLoadingContainer().getAbsolutePath();
		}

		return new FileInputStream(absolutePath);
	}

	/**
	 * @see LoadStrategy#getResourceInputStream(String)
	 */
	public InputStream getResourceInputStream(String aUri) throws IOException {
		return getLoadStrategy().getResourceInputStream(aUri);
	}

	protected JavaJDKAdapterFactory getJavaAdapterFactory() {
		return (JavaJDKAdapterFactory) EcoreUtil.getAdapterFactory(getLoadStrategy().getResourceSet().getAdapterFactories(), ReadAdaptor.TYPE_KEY);
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive returns an immutable collection of the loaded
	 *      resources in the resource set
	 */
	public Collection getLoadedMofResources() {
		return getLoadStrategy().getLoadedMofResources();
	}

	/**
	 * Insert the method's description here. Creation date: (11/29/00 6:35:08 PM)
	 */
	public ArchiveManifest getManifest() {
		if (manifest == null) {
			InputStream in = null;
			try {
				in = getInputStream(J2EEConstants.MANIFEST_URI);
				makeManifest(in);
			} catch (FileNotFoundException ex) {
				makeManifest();
			} catch (Resource.IOWrappedException ex) {
				WrappedException wrapEx = new WrappedException((ex).getWrappedException());
				if (ExtendedEcoreUtil.getFileNotFoundDetector().isFileNotFound(wrapEx))
					makeManifest();
				else
					throw new ManifestException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.io_ex_manifest_EXC_, (new Object[]{getURI()})), ex); // = "An IOException occurred reading the manifest: "
			} catch (IOException ex) {
				throw new ManifestException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.io_ex_manifest_EXC_, (new Object[]{getURI()})), ex); // = "An IOException occurred reading the manifest: "
			} finally {
				if (in != null)
					try {
						in.close();
					} catch (IOException iox) {
						//Ignore
					}
			}
		}
		//This is a hack because of the fact that the manifest does not
		// serialize correctly if
		//The version is not set. In addition to saves, the serialization is
		// used for copy
		if (manifest.getManifestVersion() == null || manifest.getManifestVersion().equals("")) //$NON-NLS-1$
			manifest.setManifestVersion("1.0");//$NON-NLS-1$
		return manifest;
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public org.eclipse.emf.ecore.resource.Resource getMofResource(java.lang.String aUri) throws FileNotFoundException, ResourceLoadException {
		return getLoadStrategy().getMofResource(aUri);
	}

	protected Resource getMofResourceMakeIfNecessary(String aUri) {
		if (getLoadStrategy() == null)
			return null;
		Resource resource = null;
		try {
			resource = getMofResource(aUri);
		} catch (java.io.FileNotFoundException ex) {
			try {
				resource = makeMofResource(aUri);
			} catch (DuplicateObjectException dox) {
				//We just checked for this; it won't happen
			}
		}
		return resource;
	}

	public org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveOptions getOptions() {
		if (options == null) {
			options = new ArchiveOptions();
		}
		return options;
	}

	/**
	 * When looking at the class path of this jar (from the manifest), some of the elements may have
	 * a relative path, thus we need to determine the install location of this jar. If the absolute
	 * path from which the archive was loaded, return the parent directory of that path; otherwise,
	 * see if the containing archive has an absolute path; if neither work, default to the current
	 * working directory
	 */
	public String getRootForRelativeDependentJars() {
		String path = null;
		Container theContainer = this;
		while (theContainer != null && path == null) {
			try {
				path = theContainer.getAbsolutePath();
			} catch (FileNotFoundException ex) {
				//Ignore
			}
			theContainer = theContainer.getLoadingContainer();
		}
		if (path == null) {
			path = System.getProperty("user.dir");//$NON-NLS-1$
			if (path == null)
				//At this point what else can we do?
				return "";//$NON-NLS-1$
			return new java.io.File(path).getAbsolutePath();
		}
		return new java.io.File(path).getParentFile().getAbsolutePath();
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public java.lang.String[] getRuntimeClassPath() {

		String absolutePath;
		try {
			absolutePath = getBinariesPath();
		} catch (IOException ex) {
			return new String[0];
		}

		List entries = new ArrayList();
		entries.add(absolutePath);

		String parentPath = new java.io.File(absolutePath).getParentFile().getAbsolutePath();
		String[] mfEntries = getManifest().getClassPathTokenized();
		entries.addAll(getEntriesAsAbsolutePaths(mfEntries, parentPath));

		return (String[]) entries.toArray(new String[entries.size()]);
	}

	/**
	 * Optional filter for saving a subset of files; filter will be applied for all save and extract
	 * invokations
	 */
	public org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.SaveFilter getSaveFilter() {
		return saveFilter;
	}

	/**
	 * Insert the method's description here. Creation date: (12/04/00 3:31:32 PM)
	 * 
	 * @return com.ibm.etools.archive.SaveStrategy
	 */
	public org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.SaveStrategy getSaveStrategy() {
		return saveStrategy;
	}

	/**
	 * Insert the method's description here. Creation date: (11/29/00 6:35:08 PM)
	 * 
	 * @return java.lang.String
	 */
	public java.lang.String getXmlEncoding() {
		return xmlEncoding;
	}

	/**
	 * The default is to do nothing; subclasses may override as necessary
	 * 
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void initializeAfterOpen() {
		//Default
	}

	public void initializeClassLoader() {
		//Some load strategies may provide a mof context for which
		//an alternate class loader is not necessary
		if (!shouldUseJavaReflection())
			return;
		ClassLoader extraCl = null;
		ClassLoader defaultCl = getDefaultClassLoader();
		if (getContainer() == null || !getContainer().isEARFile())
			extraCl = getClassPathClassLoader(defaultCl);
		ClassLoader cl = createDynamicClassLoader(defaultCl, extraCl);
		setArchiveClassLoader(cl);
		JavaJDKAdapterFactory factory = getJavaAdapterFactory();
		factory.setContextClassLoader(cl);
		factory.flushAll();
	}

	public ClassLoader createDynamicClassLoader(ClassLoader parentCl, ClassLoader extraCl) {
		return new ArchiveFileDynamicClassLoader(this, parentCl, extraCl);
	}

	/**
	 * @see com.ibm.etools.commonarchive.File
	 */
	public boolean isArchive() {
		return true;
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public boolean isDuplicate(java.lang.String aUri) {
		return containsFile(aUri) || isMofResourceLoaded(aUri) || J2EEConstants.MANIFEST_URI.equals(aUri);
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public boolean isManifestSet() {
		return manifest != null;
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public boolean isMofResourceLoaded(java.lang.String aUri) {
		return getLoadStrategy().isMofResourceLoaded(aUri);
	}

	/**
	 * By default just test the extension of the uri for one of the known archive types; subclasses
	 * may which to override.
	 * 
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public boolean isNestedArchive(java.lang.String aUri) {
		//110390.3 Error loading alt-bindings
		/*
		 * Don't infer that a folder which ends with .jar is an exploded archive; EAR file will do
		 * that IF the folder is declared as a module in the EAR
		 */
		if (getLoadStrategy().isDirectory()) {
			try {
				String path = ArchiveUtil.getOSUri(getAbsolutePath(), aUri);
				java.io.File ioFile = new java.io.File(path);
				if (!ioFile.exists() || (ioFile.isDirectory() && aUri.startsWith(J2EEConstants.ALT_INF)))
					return false;
			} catch (IOException ex) {
				return false;
			}
		}
		return ArchiveTypeDiscriminatorRegistry.INSTANCE.isKnownArchiveType(aUri);
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public boolean isOpen() {
		return getLoadStrategy() != null && getLoadStrategy().isOpen();
	}

	public ArchiveManifest makeManifest() {
		ArchiveManifest mf = new ArchiveManifestImpl();
		setManifest(mf);
		return mf;
	}

	public ArchiveManifest makeManifest(InputStream in) throws IOException {
		ArchiveManifest mf = new ArchiveManifestImpl(in);
		setManifest(mf);
		return mf;
	}

	public Resource makeMofResource(String aUri) throws DuplicateObjectException {
		return makeMofResource(aUri, null);
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive#makeMofResource(String, EList)
	 */
	public Resource makeMofResource(String aUri, EList extent) throws DuplicateObjectException {
		if (isDuplicate(aUri))
			throw new DuplicateObjectException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.duplicate_entry_EXC_, (new Object[]{aUri, getURI()}))); // = "A file or resource with uri {0} already exists in the archive named {1}"
		return getLoadStrategy().makeMofResource(aUri, extent);
	}

	/**
	 * @see Archive
	 */
	public Archive openNestedArchive(String aUri) throws OpenFailureException {
		return getCommonArchiveFactory().openNestedArchive(aUri, this);
	}

	/**
	 * @see Archive
	 */
	public Archive openNestedArchive(LooseArchive loose) throws OpenFailureException {
		return getCommonArchiveFactory().openNestedArchive(loose, this);
	}

	/**
	 * Set the value of the extra class path with no refresh of the class loader
	 */
	public void primSetExtraClasspath(java.lang.String newExtraClasspath) {
		extraClasspath = newExtraClasspath;
	}

	/**
	 * Remove references to the archive class loader to prevent gc problems or problems with temp
	 * files not getting deleted
	 */
	public void releaseClassLoader() {
		if (archiveClassLoader != null) {
			setArchiveClassLoader(null);
			getJavaAdapterFactory().setContextClassLoader(null);
		}
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void remove(File aFile) {
		getFiles().remove(aFile);
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void reopen() throws ReopenException {
		reopen(null);
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void reopen(Archive parent) throws ReopenException {
		LoadStrategy aLoadStrategy = null;
		try {
			aLoadStrategy = createLoadStrategyForReopen(parent);
		} catch (IOException ex) {
			throw new ReopenException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.io_ex_reopen_EXC_, (new Object[]{getURI()})), ex); // = "IOException occurred while reopening "
		}
		//PQ54572
		LoadStrategy current = getLoadStrategy();
		if (current != null) {
			aLoadStrategy.setResourceSet(current.primGetResourceSet());
			/*
			 * fixing problem with orphaned load strategy listening to the resource set
			 */
			current.setResourceSet(null);
		}

		setLoadStrategy(aLoadStrategy);
		initializeClassLoader();
		if (!isIndexed())
			return;
		List fileList = getFiles();
		for (int i = 0; i < fileList.size(); i++) {
			File f = (File) fileList.get(i);
			f.setOriginalURI(f.getURI());
			f.setLoadingContainer(this);
			if (f.isArchive())
				((Archive) f).reopen(this);
		}
		getCommonArchiveFactory().archiveOpened(this);
	}

	protected void replaceRoot(Resource aResource, EObject root) {
		if (aResource == null)
			return;
		EList extent = aResource.getContents();
		EObject existingRoot = null;
		if (!extent.isEmpty()) {
			existingRoot = (EObject) extent.get(0);
			if (existingRoot == root)
				return;
			extent.remove(0);
		}
		if (root != null)
			extent.add(0, root);
	}

	protected Archive resolveClasspathEntryInEAR(String entry) {
		/*
		 * Added to support runtime classpath for loose modules
		 */
		Container parent = getContainer();
		if (parent == null || !parent.isEARFile())
			return null;

		String aUri = ArchiveUtil.deriveEARRelativeURI(entry, this);
		if (aUri == null)
			return null;

		File aFile = null;
		try {
			aFile = parent.getFile(aUri);
		} catch (FileNotFoundException ex) {
			return null;
		}

		return aFile.isArchive() ? (Archive) aFile : null;
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void save() throws SaveFailureException, ReopenException {
		saveAs(getURI());
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void save(org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.SaveStrategy aStrategy) throws SaveFailureException {
		setSaveStrategy(aStrategy);
		SaveFilter existingFilter = aStrategy.getFilter();
		boolean oldDelivery = eDeliver();
		try {
			if (getOptions().isReadOnly())
				eSetDeliver(false);
			aStrategy.setFilter(getSaveFilter());
			aStrategy.save();
			try {
				aStrategy.finish();
			} catch (java.io.IOException iox) {
				throw new SaveFailureException(getURI(), iox);
			}
		} finally {
			//We have to leave the file index if we are a directory because we
			// might have
			//open file handles to archives
			if (getOptions().isReadOnly() && !getLoadStrategy().isDirectory()) {
				files.clear();
				//((BasicEList)files).setListImplementation(new ArrayList(0));
				eSetDeliver(oldDelivery);
				eAdapters().remove(getFileIndexAdapter());
				fileIndexAdapter = null;
				fileIndex = null;
			}
			setSaveStrategy(null);
			aStrategy.setFilter(existingFilter);
		}
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void saveAs(String aUri) throws SaveFailureException, ReopenException {
		saveAsNoReopen(aUri);
		reopen();
	}

	/**
	 * If we can rename it then we can delete it
	 */
	protected boolean isRenameable(java.io.File orig) {
		java.io.File origCopy1 = null;
		java.io.File origCopy2 = null;
		try {
			origCopy1 = orig.getCanonicalFile();
			origCopy2 = orig.getCanonicalFile();
		} catch (java.io.IOException ex) {
			return false;
		}
		String name = null;
		String baseName = "save.tmp"; //$NON-NLS-1$
		try {
			if (orig.getParent() != null)
				baseName = new java.io.File(orig.getParent(), baseName).getCanonicalPath();
		} catch (java.io.IOException ex) {
			return false;
		}

		java.io.File temp = null;
		int index = 0;
		do {
			name = baseName + index;
			temp = new java.io.File(name);
			index++;
		} while (temp.exists());
		return origCopy1.renameTo(temp) && temp.renameTo(origCopy2);
	}

	protected void checkWriteable(java.io.File dest) throws SaveFailureException {
		List locked = ArchiveUtil.getWriteProtectedFiles(dest, null);
		if (locked.isEmpty())
			return;

		StringBuffer msg = new StringBuffer();
		msg.append("Cannot write to file: "); //$NON-NLS-1$
		msg.append(dest.getAbsolutePath());
		msg.append('\n');
		msg.append("One or more files is write protected or locked:"); //$NON-NLS-1$
		msg.append('\n');
		for (int i = 0; i < locked.size(); i++) {
			java.io.File aFile = (java.io.File) locked.get(i);
			msg.append(aFile.getAbsolutePath());
			msg.append('\n');
		}
		throw new SaveFailureException(msg.toString());
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void saveAsNoReopen(String aUri) throws SaveFailureException {
		java.io.File aFile = new java.io.File(aUri);
		checkWriteable(aFile);
		boolean fileExisted = aFile.exists();
		//botp 142149
		//boolean inUse = getLoadStrategy().isUsing(aFile);
		SaveStrategy aSaveStrategy = null;
		try {
			try {
				java.io.File destinationFile = fileExisted ? ArchiveUtil.createTempFile(aUri, aFile.getCanonicalFile().getParentFile()) : aFile;
				aSaveStrategy = createSaveStrategyForJar(destinationFile);
				save(aSaveStrategy);
				aSaveStrategy.close();
				this.close();
				if (fileExisted) {
					cleanupAfterTempSave(aUri, aFile, destinationFile);
				}
			} catch (java.io.IOException ex) {
				throw new SaveFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.error_saving_EXC_, (new Object[]{aUri})), ex); // = "Error saving "
			}
		} catch (SaveFailureException failure) {
			try {
				if (aSaveStrategy != null)
					aSaveStrategy.close();
			} catch (IOException weTried) {
				//Ignore
			}
			if (!fileExisted)
				aFile.delete();
			throw failure;
		}

		setURI(aUri);
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void saveNoReopen() throws SaveFailureException {
		saveAsNoReopen(getURI());
	}

	/**
	 * Insert the method's description here. Creation date: (11/29/00 6:35:08 PM)
	 * 
	 * @param newArchiveClassLoader
	 *            java.lang.ClassLoader
	 */
	public void setArchiveClassLoader(java.lang.ClassLoader newArchiveClassLoader) {
		archiveClassLoader = newArchiveClassLoader;
	}

	/**
	 * Insert the method's description here. Creation date: (11/29/00 6:35:08 PM)
	 * 
	 * @param newExtraClasspath
	 *            java.lang.String
	 */
	public void setExtraClasspath(java.lang.String newExtraClasspath) {
		primSetExtraClasspath(newExtraClasspath);
		//Optimization - only re init if a cl exists; otherwise it will init on
		// demand
		if (archiveClassLoader != null)
			initializeClassLoader();
	}

	/**
	 * Insert the method's description here. Creation date: (11/29/00 6:35:08 PM)
	 */
	public void setManifest(ArchiveManifest newManifest) {
		manifest = newManifest;
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive
	 */
	public void setManifest(java.util.jar.Manifest aManifest) {
		setManifest((ArchiveManifest) new org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifestImpl(aManifest));
	}

	/**
	 * Sets the Class-path manifest entry, rebuilds the class loader, and refreshes any reflected
	 * java classes
	 */
	public void setManifestClassPathAndRefresh(String classpath) {
		ArchiveManifest mf = getManifest();
		if (manifest == null) {
			makeManifest();
		}
		mf.setClassPath(classpath);
		//Optimization - only re init if a cl exists; otherwise it will init on
		// demand
		if (archiveClassLoader != null)
			initializeClassLoader();
	}

	public void setOptions(org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveOptions newOptions) {
		options = newOptions;
	}

	/**
	 * Optional filter for saving a subset of files; filter will be applied for all save and extract
	 * invokations
	 */
	public void setSaveFilter(org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.SaveFilter newSaveFilter) {
		saveFilter = newSaveFilter;
	}

	/**
	 * Insert the method's description here. Creation date: (12/04/00 3:31:32 PM)
	 * 
	 * @param newSaveStrategy
	 *            com.ibm.etools.archive.SaveStrategy
	 */
	public void setSaveStrategy(org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.SaveStrategy newSaveStrategy) {
		saveStrategy = newSaveStrategy;
		if (newSaveStrategy != null) {
			newSaveStrategy.setArchive(this);
		}
	}

	/**
	 * Insert the method's description here. Creation date: (11/29/00 6:35:08 PM)
	 * 
	 * @param newXmlEncoding
	 *            java.lang.String
	 */
	public void setXmlEncoding(java.lang.String newXmlEncoding) {
		xmlEncoding = newXmlEncoding;
	}

	/**
	 * Determine whether java reflection should be set up for this archive
	 */
	public boolean shouldUseJavaReflection() {
		return getOptions().useJavaReflection() && getLoadStrategy().isClassLoaderNeeded();
	}

	protected void throwResourceLoadException(String resourceUri, Exception ex) throws ResourceLoadException {
		throw new ResourceLoadException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.load_resource_EXC_, (new Object[]{resourceUri, getURI()})), ex); // = "Could not load resource "{0}" in archive "{1}""
	}

	public String getResourcesPath() throws FileNotFoundException {
		return getLoadStrategy().getResourcesPath();
	}

	public String getBinariesPath() throws FileNotFoundException {
		return getLoadStrategy().getBinariesPath();
	}

	protected RuntimeClasspathEntry[] emptyClasspath() {
		return new RuntimeClasspathEntry[0];
	}

	protected String internalGetBinariesPath() {
		try {
			return getBinariesPath();
		} catch (FileNotFoundException ex) {
			return null;
		}
	}

	/**
	 * By default return just the contents of this archive
	 */
	public RuntimeClasspathEntry[] getLocalRuntimeClassPath() {

		String absolutePath = internalGetBinariesPath();
		if (absolutePath == null)
			return emptyClasspath();
		return new RuntimeClasspathEntry[]{createRuntimeClasspathEntry(absolutePath)};
	}

	
 	protected RuntimeClasspathEntry[] getDependencyClassPathAtThisLevel() {
		// BZ 170532: Don't use the archive's absolute path when the
		// archive is loosely mapped.  The current archive's absolute
		// path, generally, will not be in a fixed location relative
		// to the path of the parent application.
		String parentPath = getParentPath();
		if ( parentPath == null )
 			return emptyClasspath();
		
 		String[] mfEntries = getManifest().getClassPathTokenized();
		if ( mfEntries.length == 0 )
 			return emptyClasspath();
		
 		List entries = new ArrayList();
		entries.addAll( createRuntimeClasspathEntries(mfEntries, parentPath) );
 
		return (RuntimeClasspathEntry[]) entries.toArray( new RuntimeClasspathEntry[ entries.size() ] );
 	}

	/**
	 * <p>Answer a parent path for use by the receiver.  Take into
	 * account wehther the receiver is a loose application or not.
	 * 
	 * <p>Answer null in case an error is encountered while determining
	 * the parent path.</p>
	 * 
	 * <p>Added for BZ 170532.</p>
	 * 
	 * @return A parent path for use by the receiver.  Null in case of an error.
	 * 
	 *  @see getDependencyClassPathAtThisLevel()
	 */
	protected String getParentPath() {
		try {
			if ( (getLoadStrategy().getLooseArchive() != null) && getContainer().isEARFile() ) {
				return getEARFile().getBinariesPath();
			} else {
				return new java.io.File(getBinariesPath()).getParentFile().getAbsolutePath();
			}
		} catch (FileNotFoundException e) {
			return null;
		}
	}
	
	
	public RuntimeClasspathEntry[] getFullRuntimeClassPath() {
		return concat(getLocalRuntimeClassPath(), getDependencyClassPath());
	}

	protected RuntimeClasspathEntry[] concat(RuntimeClasspathEntry[] array1, RuntimeClasspathEntry[] array2) {
		List temp = new ArrayList();
		temp.addAll(Arrays.asList(array1));
		temp.addAll(Arrays.asList(array2));
		return (RuntimeClasspathEntry[]) temp.toArray(new RuntimeClasspathEntry[temp.size()]);
	}

	public RuntimeClasspathEntry[] getDependencyClassPath() {
		List entries = new ArrayList();
		Set visited = new HashSet();
		Set processedEntries = new HashSet();
		visited.add(this);
		getDependencyClassPath(visited, entries, processedEntries, this);
		return (RuntimeClasspathEntry[]) entries.toArray(new RuntimeClasspathEntry[entries.size()]);
	}

	protected void getDependencyClassPath(Set visitedArchives, List entries, Set processedEntries, Archive current) {

		RuntimeClasspathEntry[] local = ((ArchiveImpl) current).getDependencyClassPathAtThisLevel();
		for (int i = 0; i < local.length; i++) {
			RuntimeClasspathEntry entry = local[i];
			if (!processedEntries.contains(entry)) {
				entries.add(entry);
				processedEntries.add(entry);
			}
			Archive resolved = entry.getReferencedArchive();
			if (resolved == null)
				ClasspathUtil.processManifest(entry.getAbsolutePath(), entries, processedEntries);
			else if (!visitedArchives.contains(resolved)) {
				visitedArchives.add(resolved);
				getDependencyClassPath(visitedArchives, entries, processedEntries, resolved);
			}

		}
	}

	protected EARFile getEARFile() {
		Container parent = getContainer();
		if (parent == null || !(parent instanceof EARFile))
			return null;
		return (EARFile) parent;
	}

	protected Archive getResolvedArchive(String mfValue, EARFile ear) {
		String aUri = ArchiveUtil.deriveEARRelativeURI(mfValue, this);
		if (aUri == null)
			return null;
		try {
			return (Archive) ear.getFile(aUri);
		} catch (FileNotFoundException ex) {
			return null;
		} catch (ClassCastException ex2) {
			return null;
		}
	}

	/**
	 * @see com.ibm.etools.commonarchive.Archive#hasClasspathVisibilityTo(Archive)
	 */
	public boolean hasClasspathVisibilityTo(Archive other) {
		if (other == null)
			return false;
		EARFile ear = getEARFile();
		if (ear == null)
			return false;
		Set visited = new HashSet();
		return hasClasspathVisibilityTo(other, visited, ear);
	}

	public boolean hasClasspathVisibilityTo(Archive other, Set visited, EARFile ear) {
		if (this == other)
			return true;
		if (visited.contains(this))
			return false;
		visited.add(this);
		String[] mfEntries = getManifest().getClassPathTokenized();
		for (int i = 0; i < mfEntries.length; i++) {
			Archive anArchive = getResolvedArchive(mfEntries[i], ear);
			if (anArchive != null && anArchive.hasClasspathVisibilityTo(other, visited, ear))
				return true;
		}
		return false;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.j2ee.internal.commonarchivecore.Archive#isType(java.lang.String)
	 */
	public boolean isType(String type) {

		return (types != null && getTypes().contains(type));
	}

}