Java tutorial
/******************************************************************************* * Copyright (c) 2003, 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.internal.archive; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.Enumeration; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.zip.ZipEntry; import java.util.zip.ZipException; import java.util.zip.ZipFile; import org.eclipse.core.resources.IContainer; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IProject; 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.eclipse.core.runtime.Path; import org.eclipse.emf.common.util.URI; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.IPackageFragmentRoot; import org.eclipse.jdt.core.JavaCore; import org.eclipse.jst.common.internal.modulecore.SingleRootUtil; import org.eclipse.jst.j2ee.classpathdep.IClasspathDependencyConstants; import org.eclipse.jst.j2ee.componentcore.J2EEModuleVirtualComponent; import org.eclipse.jst.j2ee.internal.J2EEConstants; import org.eclipse.jst.j2ee.internal.archive.operations.EARArchiveOpsResourceHandler; import org.eclipse.jst.j2ee.internal.classpathdep.ClasspathDependencyManifestUtil; import org.eclipse.jst.j2ee.internal.classpathdep.ClasspathDependencyVirtualComponent; import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin; import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities; import org.eclipse.jst.jee.archive.AbstractArchiveLoadAdapter; import org.eclipse.jst.jee.archive.ArchiveModelLoadException; import org.eclipse.jst.jee.archive.IArchive; import org.eclipse.jst.jee.archive.IArchiveLoadAdapter; import org.eclipse.jst.jee.archive.IArchiveResource; import org.eclipse.jst.jee.archive.internal.ArchiveURIConverter; import org.eclipse.jst.jee.archive.internal.ArchiveUtil; import org.eclipse.wst.common.componentcore.UnresolveableURIException; import org.eclipse.wst.common.componentcore.internal.ComponentResource; import org.eclipse.wst.common.componentcore.internal.DependencyType; import org.eclipse.wst.common.componentcore.internal.StructureEdit; import org.eclipse.wst.common.componentcore.resources.IVirtualComponent; import org.eclipse.wst.common.componentcore.resources.IVirtualContainer; import org.eclipse.wst.common.componentcore.resources.IVirtualFile; import org.eclipse.wst.common.componentcore.resources.IVirtualFolder; import org.eclipse.wst.common.componentcore.resources.IVirtualReference; import org.eclipse.wst.common.componentcore.resources.IVirtualResource; public abstract class ComponentArchiveLoadAdapter extends AbstractArchiveLoadAdapter { protected static final String DOT_SQLJ = ".sqlj"; //$NON-NLS-1$ protected static final String DOT_JSP = ".jsp"; //$NON-NLS-1$ protected static final String DOT_PROJECT = ".project"; //$NON-NLS-1$ protected static final String DOT_CLASSPATH = ".classpath"; //$NON-NLS-1$ protected static final String DOT_SETTINGS = ".settings"; //$NON-NLS-1$ protected static final String DOT_CVS_IGORE = ".cvsignore"; //$NON-NLS-1$ protected IVirtualComponent vComponent; protected boolean exportSource = true; protected boolean optimizeMembers = false; private List<ZipFile> zipFiles = new ArrayList<ZipFile>(); private List<String> javaClasspathURIs = new ArrayList<String>(); protected boolean includeClasspathComponents = true; protected class FilesHolder { private Map<IPath, IArchiveResource> pathsToArchiveResources = new HashMap<IPath, IArchiveResource>(); private Map<IPath, IResource> pathsToWorkbenchResources = new HashMap<IPath, IResource>(); private Map<IResource, IPath> workbenchResourcesToPaths = new HashMap<IResource, IPath>(); private Map<IPath, java.io.File> pathsToDiskFiles = new HashMap<IPath, java.io.File>(); private Map pathsToZipEntry = new HashMap(); public void removeIFile(IFile file) { IPath path = workbenchResourcesToPaths.get(file); remove(path); } public void remove(IPath path) { pathsToArchiveResources.remove(path); Object resource = pathsToWorkbenchResources.remove(path); if (resource != null) { workbenchResourcesToPaths.remove(resource); } pathsToDiskFiles.remove(path); } public void addFile(IArchiveResource file) { IPath path = file.getPath(); pathsToArchiveResources.put(path, file); } public void addFile(IArchiveResource file, java.io.File externalDiskFile) { IPath path = file.getPath(); pathsToArchiveResources.put(path, file); pathsToDiskFiles.put(path, externalDiskFile); } public void addFile(IArchiveResource file, IResource resource) { IPath path = file.getPath(); pathsToArchiveResources.put(path, file); pathsToWorkbenchResources.put(path, resource); } public InputStream getInputStream(IPath path) throws IOException, FileNotFoundException { java.io.File diskFile = null; if (pathsToDiskFiles.containsKey(path)) { diskFile = pathsToDiskFiles.get(path); } else if (pathsToWorkbenchResources.containsKey(path)) { IResource resource = pathsToWorkbenchResources.get(path); diskFile = new java.io.File(resource.getLocation().toOSString()); } if (diskFile != null) { return new FileInputStream(diskFile); } else if (pathsToZipEntry.containsKey(path)) { Map fileURIMap = (Map) pathsToZipEntry.get(path); Iterator it = fileURIMap.keySet().iterator(); String sourceFileUri = ""; //$NON-NLS-1$ ZipFile zipFile = null; // there is only one key, pair while (it.hasNext()) { sourceFileUri = (String) it.next(); zipFile = (ZipFile) fileURIMap.get(sourceFileUri); } if (zipFile != null) { ZipEntry entry = zipFile.getEntry(sourceFileUri); InputStream in = zipFile.getInputStream(entry); return in; } throw new IOException(); } else { IArchiveResource res = getArchiveResource(path); return ComponentArchiveLoadAdapter.this.getSuperInputStream(res); } } public List<IArchiveResource> getFiles() { return new ArrayList<IArchiveResource>(pathsToArchiveResources.values()); } public boolean contains(IPath path) { return pathsToArchiveResources.containsKey(path); } public IArchiveResource getArchiveResource(IPath path) { return pathsToArchiveResources.get(path); } public void addEntry(ZipEntry entry, ZipFile zipFile, IPath runtimePath) { IPath innerRuntimePath = runtimePath; if (innerRuntimePath != null) { if (!innerRuntimePath.equals("/")) //$NON-NLS-1$ innerRuntimePath = innerRuntimePath.append(entry.getName()); else innerRuntimePath = new Path(entry.getName()); } else { innerRuntimePath = new Path(entry.getName()); } IArchiveResource file = createFile(innerRuntimePath); Map<String, ZipFile> fileURIMap = new HashMap<String, ZipFile>(); fileURIMap.put(entry.getName(), zipFile); pathsToZipEntry.put(file.getPath(), fileURIMap); pathsToArchiveResources.put(file.getPath(), file); } } protected FilesHolder filesHolder; private IVirtualFile manifestFile = null; public ComponentArchiveLoadAdapter(IVirtualComponent vComponent) { this(vComponent, true); } public ComponentArchiveLoadAdapter(IVirtualComponent vComponent, boolean includeClasspathComponents) { this.vComponent = vComponent; filesHolder = new FilesHolder(); setIncludeClasspathComponents(includeClasspathComponents); } public void setIncludeClasspathComponents(boolean includeClasspathComponents) { this.includeClasspathComponents = includeClasspathComponents; if (includeClasspathComponents) { this.manifestFile = vComponent.getRootFolder().getFile(new Path(J2EEConstants.MANIFEST_URI)); saveJavaClasspathReferences(); } else { this.manifestFile = null; javaClasspathURIs.clear(); } } @Override public IArchiveResource getArchiveResource(IPath resourcePath) throws FileNotFoundException { initArchiveResource(resourcePath); return filesHolder.getArchiveResource(resourcePath); } @Override public boolean containsArchiveResource(IPath path) { initArchiveResource(path); return filesHolder.contains(path); } /** * Will lazily initialize File type ArchiveResources contained in the component structure without loading the entire * archive. If the File can not be found, then the entire structure will be loaded. * @param resourcePath */ protected void initArchiveResource(IPath resourcePath) { if (archiveResourcesInitialized) { //if the entire archive has been initialized, there is no need to repeat return; } if (filesHolder.contains(resourcePath)) { //if the archive already knows about the resource return return; } initSourceRoots(); // want to be quick if possible, so only try to load from the component structure // if the file is not present there, then look everywhere IVirtualFolder rootFolder = vComponent.getRootFolder(); IVirtualFile vFile = rootFolder.getFile(resourcePath); if (vFile.exists()) { IPath runtimePath = vFile.getRuntimePath(); if (runtimePath != null) { runtimePath = runtimePath.setDevice(null).makeRelative(); if (runtimePath.equals(resourcePath)) { boolean inJavaSrc = inJavaSrc(vFile); if (aggregateResource(vFile, runtimePath, inJavaSrc, IArchiveResource.FILE_TYPE) != null) { return; //found the file and added it } } } } //if it was not found above then do the full initialize initArchiveResources(); } protected boolean sourceRootsInitialized = false; protected void initSourceRoots() { if (!sourceRootsInitialized) { sourceRootsInitialized = true; try { IPackageFragmentRoot[] srcPkgs = J2EEProjectUtilities.getSourceContainers(vComponent.getProject()); sourceRoots = new IResource[srcPkgs.length]; for (int i = 0; i < srcPkgs.length; i++) { sourceRoots[i] = srcPkgs[i].getCorrespondingResource(); } inJavaSrc = false; } catch (CoreException e) { J2EEPlugin.logError(e); } } } protected boolean archiveResourcesInitialized = false; protected boolean membersOptimized = false; protected void initArchiveResources() { if (!archiveResourcesInitialized) { archiveResourcesInitialized = true; if (shouldOptimize()) { attemptOptimization(); } if (!membersOptimized) { aggregateSourceFiles(); aggregateClassFiles(); } addUtilities(); } } protected void attemptOptimization() { SingleRootUtil util = new SingleRootUtil(getComponent()); IContainer rootContainer = util.getSingleRoot(); if (rootContainer != null) { try { membersOptimized = true; optimizeMembers(Path.EMPTY, rootContainer); } catch (CoreException e) { J2EEPlugin.logError(e); } } } @Override public List<IArchiveResource> getArchiveResources() { initArchiveResources(); return filesHolder.getFiles(); } public IResource getWorkbenchResources(IPath path) { return filesHolder.pathsToWorkbenchResources.get(path); } public File getExternalFiles(IPath path) { return filesHolder.pathsToDiskFiles.get(path); } /** * Adds library cp entries that point to class folders and have been tagged with the publish/export attribute. */ protected void addMappedClassFolders(final IPath targetRuntimePath) { // retrieve all mapped class folders if (vComponent instanceof J2EEModuleVirtualComponent) { try { final J2EEModuleVirtualComponent j2eeComponent = (J2EEModuleVirtualComponent) vComponent; final IVirtualReference[] cpRefs = j2eeComponent.getJavaClasspathReferences(); for (int j = 0; j < cpRefs.length; j++) { final IVirtualReference ref = cpRefs[j]; final IPath runtimePath = ref.getRuntimePath(); // only process mappings with the specified runtime path if (ref.getReferencedComponent() instanceof ClasspathDependencyVirtualComponent) { if (runtimePath.equals(targetRuntimePath) || runtimePath.equals(IClasspathDependencyConstants.WEB_INF_CLASSES_PATH)) { final ClasspathDependencyVirtualComponent comp = (ClasspathDependencyVirtualComponent) ref .getReferencedComponent(); if (comp.isClassFolder()) { final IContainer classFolder = comp.getClassFolder(); if (classFolder != null && classFolder.exists()) { aggregateOutputFiles(new IResource[] { classFolder }, runtimePath.makeRelative(), classFolder.getProjectRelativePath().segmentCount()); } } } } } } catch (CoreException e) { J2EEPlugin.logError(e); } } } protected void saveJavaClasspathReferences() { if (vComponent instanceof J2EEModuleVirtualComponent) { final J2EEModuleVirtualComponent j2eeComp = (J2EEModuleVirtualComponent) vComponent; final IVirtualReference[] refs = j2eeComp.getJavaClasspathReferences(); if (refs == null) { return; } for (int i = 0; i < refs.length; i++) { if (refs[i].getRuntimePath() .equals(IClasspathDependencyConstants.RUNTIME_MAPPING_INTO_CONTAINER_PATH)) { javaClasspathURIs.add(refs[i].getArchiveName()); } } } } protected void addUtilities() { IVirtualReference[] components = vComponent.getReferences(); for (int i = 0; i < components.length; i++) { IVirtualReference reference = components[i]; IVirtualComponent referencedComponent = reference.getReferencedComponent(); if (referencedComponent.isBinary() && reference.getDependencyType() == DependencyType.CONSUMES) { java.io.File diskFile = (java.io.File) referencedComponent.getAdapter(java.io.File.class); ZipFile zipFile; IPath path = reference.getRuntimePath(); try { zipFile = ArchiveUtil.newZipFile(diskFile); zipFiles.add(zipFile); Enumeration enumeration = zipFile.entries(); while (enumeration.hasMoreElements()) { ZipEntry entry = (ZipEntry) enumeration.nextElement(); filesHolder.addEntry(entry, zipFile, path); } } catch (ZipException e) { J2EEPlugin.logError(e); } catch (IOException e) { J2EEPlugin.logError(e); } } } } /** * This is a cache of the IResource roots for all java source folders and is * used by {@link #inJavaSrc(IVirtualResource)}. */ private IResource[] sourceRoots = null; protected void aggregateSourceFiles() { try { initSourceRoots(); IVirtualFolder rootFolder = vComponent.getRootFolder(); IVirtualResource[] members = rootFolder.members(); inJavaSrc = false; aggregateFiles(members); } catch (CoreException e) { J2EEPlugin.logError(e); } } protected void aggregateClassFiles() { StructureEdit se = null; try { IPackageFragmentRoot[] sourceRoots = J2EEProjectUtilities.getSourceContainers(vComponent.getProject()); se = StructureEdit.getStructureEditForRead(vComponent.getProject()); for (int i = 0; i < sourceRoots.length; i++) { IPath outputPath = sourceRoots[i].getRawClasspathEntry().getOutputLocation(); if (outputPath == null) { IProject project = vComponent.getProject(); if (project.hasNature(JavaCore.NATURE_ID)) { IJavaProject javaProject = JavaCore.create(project); outputPath = javaProject.getOutputLocation(); } } if (outputPath != null) { IContainer javaOutputContainer = outputPath.segmentCount() > 1 ? (IContainer) ResourcesPlugin.getWorkspace().getRoot().getFolder(outputPath) : (IContainer) ResourcesPlugin.getWorkspace().getRoot() .getProject(outputPath.lastSegment()); IPath runtimePath = null; try { ComponentResource[] componentResources = se .findResourcesBySourcePath(sourceRoots[i].getResource().getProjectRelativePath()); if (componentResources.length > 0) { IPath tmpRuntimePath = componentResources[0].getRuntimePath(); IPath tmpSourcePath = componentResources[0].getSourcePath(); if (!tmpRuntimePath.equals(tmpSourcePath)) { while (tmpSourcePath.segmentCount() > 0 && tmpRuntimePath.segmentCount() > 0 && tmpRuntimePath.lastSegment().equals(tmpSourcePath.lastSegment())) { tmpRuntimePath = tmpRuntimePath.removeLastSegments(1); tmpSourcePath = tmpSourcePath.removeLastSegments(1); } if (tmpRuntimePath.segmentCount() != 0) { runtimePath = tmpRuntimePath.makeRelative(); } } } } catch (UnresolveableURIException e) { J2EEPlugin.logError(e); } if (null == runtimePath) { runtimePath = new Path(""); //$NON-NLS-1$ } aggregateOutputFiles(new IResource[] { javaOutputContainer }, runtimePath, javaOutputContainer.getProjectRelativePath().segmentCount()); } } } catch (CoreException e) { J2EEPlugin.logError(e); } finally { if (se != null) { se.dispose(); } } } protected boolean aggregateOutputFiles(IResource[] resources, final IPath runtimePathPrefix, int outputFolderSegmentCount) throws CoreException { boolean fileAdded = false; for (int i = 0; i < resources.length; i++) { IArchiveResource cFile = null; if (!resources[i].exists()) { continue; } // We have to avoid duplicates between the source and output folders // (non-java // resources) IPath runtimePath = runtimePathPrefix .append(resources[i].getProjectRelativePath().removeFirstSegments(outputFolderSegmentCount)); if (runtimePath == null) continue; if (resources[i].getType() == IResource.FILE) { if (!shouldInclude(runtimePath)) continue; cFile = createFile(runtimePath); cFile.setLastModified(getLastModified(resources[i])); filesHolder.addFile(cFile, resources[i]); fileAdded = true; } else if (shouldInclude((IContainer) resources[i])) { IResource[] nestedResources = ((IContainer) resources[i]).members(); aggregateOutputFiles(nestedResources, runtimePathPrefix, outputFolderSegmentCount); if (!filesHolder.contains(runtimePath)) { if (!shouldInclude(runtimePath)) continue; cFile = createDirectory(runtimePath); cFile.setLastModified(getLastModified(resources[i])); filesHolder.addFile(cFile, resources[i]); fileAdded = true; } } } return fileAdded; } /** * This is used to track whether {@link #aggregateFiles(IVirtualResource[])} * is currently within a Java Source folder. */ private boolean inJavaSrc = false; protected boolean aggregateFiles(IVirtualResource[] virtualResources) throws CoreException { boolean fileAdded = false; for (int i = 0; i < virtualResources.length; i++) { if (!virtualResources[i].exists()) { continue; } // We have to avoid duplicates between the source and output folders // (non-java // resources) IPath runtimePath = virtualResources[i].getRuntimePath(); if (runtimePath == null) continue; runtimePath = runtimePath.setDevice(null).makeRelative(); if (filesHolder.contains(runtimePath)) continue; if (virtualResources[i].getType() == IVirtualResource.FILE) { if (aggregateResource(virtualResources[i], runtimePath, inJavaSrc, IArchiveResource.FILE_TYPE) != null) { fileAdded = true; } } else if (shouldInclude((IVirtualContainer) virtualResources[i])) { boolean inJavaSrcAtThisLevel = inJavaSrc; try { if (!inJavaSrc) { // if not already inside a Java src dir, check again inJavaSrc = inJavaSrc(virtualResources[i]); } IVirtualResource[] nestedVirtualResources = ((IVirtualContainer) virtualResources[i]).members(); aggregateFiles(nestedVirtualResources); if (!filesHolder.contains(runtimePath)) { if (aggregateResource(virtualResources[i], runtimePath, inJavaSrc, IArchiveResource.DIRECTORY_TYPE) != null) { fileAdded = true; } } } finally { inJavaSrc = inJavaSrcAtThisLevel; } } } return fileAdded; } protected IArchiveResource aggregateResource(IVirtualResource virtualResource, IPath runtimePath, boolean inJavaSrc, int archiveResourceType) { if (!shouldInclude(runtimePath)) { return null; } IResource resource = virtualResource.getUnderlyingResource(); // want to ignore derived resources nested within Java src // directories; this covers the case where // a user has nested a Java output directory within a Java src // directory (note: should ideally be // respecting Java src path exclusion filters) if (inJavaSrc && resource.isDerived()) { return null; } IArchiveResource cFile = null; switch (archiveResourceType) { case IArchiveResource.FILE_TYPE: cFile = createFile(runtimePath); break; case IArchiveResource.DIRECTORY_TYPE: cFile = createDirectory(runtimePath); break; default: return null; } cFile.setLastModified(getLastModified(resource)); filesHolder.addFile(cFile, resource); return cFile; } /** * Determines if the specified IVirtualResource maps to a IResource that is * contained within a Java src root. * * @param virtualResource * IVirtualResource to check. * @param sourceRoots * Current Java src roots. * @return True if contained in a Java src root, false otherwise. */ protected boolean inJavaSrc(final IVirtualResource virtualResource) { if (sourceRoots.length == 0) { return false; } // all mapped resources must be associated with Java src for the // resource to be considered in Java src final IResource[] resources = virtualResource.getUnderlyingResources(); boolean inJavaSrc = false; for (int i = 0; i < resources.length; i++) { inJavaSrc = false; for (int j = 0; j < sourceRoots.length; j++) { if (sourceRoots[j].getFullPath().isPrefixOf(resources[i].getFullPath())) { inJavaSrc = true; break; } } // if this one was not in Java src, can break if (!inJavaSrc) { break; } } return inJavaSrc; } protected long getLastModified(IResource aResource) { return aResource.getLocation().toFile().lastModified(); } protected void optimizeMembers(IPath path, IContainer container) throws CoreException { IResource[] resources; resources = container.members(); if (resources != null) { int size = resources.length; for (int i = 0; i < size; i++) { IResource resource = resources[i]; IArchiveResource cFile = null; if (resource != null && resource.exists()) { IPath deployPath = path.append(resource.getName()); if (filesHolder.contains(deployPath)) { continue; } if (resource instanceof IContainer) { IContainer container2 = (IContainer) resource; cFile = createDirectory(deployPath); optimizeMembers(deployPath, container2); } else if ((resource instanceof IFile) && (isExportSource() || !isSource(deployPath))) { cFile = createFile(deployPath); } } if (cFile != null) { cFile.setLastModified(getLastModified(resource)); filesHolder.addFile(cFile, resource); } } } } public void setExportSource(boolean newExportSource) { exportSource = newExportSource; } public boolean isExportSource() { return exportSource; } public void setOptimize(boolean optimize) { optimizeMembers = optimize; } public boolean shouldOptimize() { return optimizeMembers; } public boolean shouldUpdateManifest(IArchiveResource archiveResource) { IPath path = archiveResource.getPath(); if (includeClasspathComponents && path.equals(new Path(J2EEConstants.MANIFEST_URI)) && !javaClasspathURIs.isEmpty() && manifestFile != null && manifestFile.getUnderlyingFile() != null && manifestFile.getUnderlyingFile().exists()) { return true; } return false; } protected boolean shouldInclude(IContainer aContainer) { return true; } protected boolean shouldInclude(IVirtualContainer vContainer) { IContainer iContainer = (IContainer) vContainer.getUnderlyingResource(); return shouldInclude(iContainer); } // TODO add a mechanism for ignoring specific file types protected boolean shouldInclude(IPath path) { String lastSegment = path.lastSegment(); if (null == lastSegment) { return false; } if (lastSegment.endsWith(DOT_PROJECT) || lastSegment.endsWith(DOT_CLASSPATH) || lastSegment.endsWith(DOT_CVS_IGORE) || path.segment(0).startsWith(DOT_SETTINGS)) { return false; } return isExportSource() || !isSource(path); } // TODO add a mechanism for ignoring specific file types protected boolean isSource(IPath path) { if (path == null) return false; return path.lastSegment().endsWith(JavaEEArchiveUtilities.DOT_JAVA) || path.lastSegment().endsWith(DOT_SQLJ); } protected void addExternalFile(IPath path, java.io.File externalDiskFile) { IArchiveResource aFile = createFile(path); filesHolder.addFile(aFile, externalDiskFile); } protected InputStream getSuperInputStream(IArchiveResource archiveResource) throws IOException, FileNotFoundException { if (archiveResource.getType() == IArchive.ARCHIVE_TYPE) { IArchiveLoadAdapter nestedLoadAdapter = ((IArchive) archiveResource).getLoadAdapter(); if (nestedLoadAdapter instanceof ComponentArchiveLoadAdapter) { ((ComponentArchiveLoadAdapter) nestedLoadAdapter).setExportSource(isExportSource()); } } return super.getInputStream(archiveResource); } @Override public InputStream getInputStream(IArchiveResource archiveResource) throws IOException, FileNotFoundException { // If the MANIFEST.MF of a module component is being requested and that // module component references // Java build path-based components, need to dynamically update the // manifest classpath to reflect the resolved // contributions from the build path if (shouldUpdateManifest(archiveResource)) { // update the manifest classpath for the component ByteArrayOutputStream baos = new ByteArrayOutputStream(); ClasspathDependencyManifestUtil.updateManifestClasspath(manifestFile.getUnderlyingFile(), javaClasspathURIs, baos); return new ByteArrayInputStream(baos.toByteArray()); } IPath path = archiveResource.getPath(); if (filesHolder.contains(path)) { return filesHolder.getInputStream(path); } IVirtualFolder rootFolder = vComponent.getRootFolder(); IVirtualResource vResource = rootFolder.findMember(path); String filePath = null; if (null != vResource && vResource.exists()) { filePath = vResource.getUnderlyingResource().getLocation().toOSString(); java.io.File file = new java.io.File(filePath); return new FileInputStream(file); } String eString = EARArchiveOpsResourceHandler.ARCHIVE_OPERATION_FileNotFound; throw new FileNotFoundException(eString); } public IVirtualComponent getComponent() { return vComponent; } protected JavaEEEMFArchiveAdapterHelper emfHelper = null; protected void initEMFHelper() { if (emfHelper == null) { emfHelper = new JavaEEEMFArchiveAdapterHelper(getArchive()); emfHelper.setArchiveURIConverter(new ArchiveURIConverter(emfHelper.getArchive()) { @Override protected URI convertPathToURI(IPath modelObjectPath) { // TODO find a better way to getplatformURI IPath path = getComponent().getRootFolder().getFile(modelObjectPath).getUnderlyingFile() .getFullPath(); return URI.createURI("platform:/resource/" + path.toString()); //$NON-NLS-1$ } }); } } @Override public boolean containsModelObject(IPath modelObjectPath) { initEMFHelper(); IPath innerModelObjectPath = modelObjectPath; if (IArchive.EMPTY_MODEL_PATH == innerModelObjectPath) { innerModelObjectPath = getDefaultModelObjectPath(); } return emfHelper.containsModelObject(innerModelObjectPath); } @Override public Object getModelObject(IPath modelObjectPath) throws ArchiveModelLoadException { initEMFHelper(); IPath innerModelObjectPath = modelObjectPath; if (IArchive.EMPTY_MODEL_PATH == innerModelObjectPath) { innerModelObjectPath = getDefaultModelObjectPath(); } return emfHelper.getModelObject(innerModelObjectPath); } protected IPath getDefaultModelObjectPath() { return new Path("/"); //$NON-NLS-1$ } @Override public String toString() { int packageLength = this.getClass().getPackage().getName().length() + 1; StringBuffer buffer = new StringBuffer(this.getClass().getName().substring(packageLength)); buffer.append(", Component: "); //$NON-NLS-1$ buffer.append(getComponent()); return buffer.toString(); } /** * protected IProgressMonitor monitor = null; * * public void setProgressMonitor(IProgressMonitor monitor){ this.monitor = * monitor; } * * protected final int FILE_SAVE_WORK = 100; * * public FileIterator getFileIterator() throws IOException { return new * FileIteratorImpl(getContainer().getFiles()){ protected SubProgressMonitor * lastSubMon = null; boolean firstVisit = true; * * public File next() { if(firstVisit){ firstVisit = false; if(monitor != * null){ * monitor.beginTask(ProjectSupportResourceHandler.getString(ProjectSupportResourceHandler.Exporting_archive, * new Object [] { getContainer().getURI() }), files.size() * * FILE_SAVE_WORK); } } if(lastSubMon != null){ lastSubMon.done(); * lastSubMon = null; } else if(monitor != null){ * monitor.worked(FILE_SAVE_WORK); } File file = super.next(); if(monitor != * null){ if(file.isContainer() && * ComponentArchiveLoadAdapter.class.isInstance(((ContainerImpl)file).getLoadStrategy())){ * ComponentArchiveLoadAdapter ls = * (ComponentArchiveLoadAdapter)((ContainerImpl)file).getLoadStrategy(); * lastSubMon = new SubProgressMonitor(monitor, FILE_SAVE_WORK, * SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK); * ls.setProgressMonitor(lastSubMon); } else { * monitor.subTask(file.getURI()); } } return file; } }; } */ }