plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/archive/operations/RARProjectLoadStrategyImpl.java - gerrit/jeetools/webtools.javaee - Git at Google

 /*******************************************************************************
  * Copyright (c) 2003, 2004 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.jca.archive.operations;


 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.jem.util.emf.workbench.WorkbenchURIConverter;
 import org.eclipse.jem.util.emf.workbench.WorkbenchURIConverterImpl;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.File;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.ArchiveRuntimeException;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.OpenFailureException;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveOptions;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveUtil;
 import org.eclipse.jst.j2ee.internal.J2EEConstants;
 import org.eclipse.jst.j2ee.internal.archive.operations.J2EELoadStrategyImpl;
 import org.eclipse.jst.j2ee.internal.jca.operations.ConnectorNatureRuntime;

 /**
  * Class defines the loading mechanism for RAR projects.
  */
 public class RARProjectLoadStrategyImpl extends J2EELoadStrategyImpl {

 	//The module root of the RAR, usually a "connectorModule" folder
 	private IContainer moduleRoot;
 	private int moduleRootSegmentCount;
 	private Map innerClasses;

 	public static String[] knownLibExtensions = {".jar", //$NON-NLS-1$
 				".zip", //$NON-NLS-1$
 				".so", //$NON-NLS-1$
 				".o", //$NON-NLS-1$
 				".sl", //$NON-NLS-1$
 				".dll", //$NON-NLS-1$
 	}; //$NON-NLS-1$

 	public RARProjectLoadStrategyImpl(IProject aProject) {
 		super();
 		project = aProject;
 		filesList = new ArrayList();
 		init();
 	}

 	/**
 	 * @see org.eclipse.jst.j2ee.internal.internal.internal.archive.operations.J2EELoadStrategyImpl#getFiles()
 	 */
 	public List getFiles() {
 		List files = super.getFiles();
 		files.addAll(getNestedJARsFromSourceFolders());
 		return files;
 	}

 	/**
 	 * @see org.eclipse.jst.j2ee.internal.internal.internal.archive.operations.J2EELoadStrategyImpl#getFiles(List)
 	 */
 	protected ArrayList getFiles(List projectResources) throws Exception {
 		return super.getFiles(projectResources);
 	}

 	/**
 	 * @see org.eclipse.jst.j2ee.internal.internal.internal.archive.operations.J2EELoadStrategyImpl#shouldInclude(IContainer)
 	 */
 	protected boolean shouldInclude(IContainer iContainer) {
 		return moduleRoot.equals(iContainer) || !getSourceFolders().contains(iContainer);
 	}

 	private Collection getNestedJARsFromSourceFolders() {
 		List localSourceFolders = getSourceFolders();
 		List result = new ArrayList(localSourceFolders.size());
 		for (int i = 0; i < localSourceFolders.size(); i++) {
 			IFolder folder = (IFolder) localSourceFolders.get(i);
 			File aFile = getNestedJARFromSourceFolder(folder);
 			if (aFile != null)
 				result.add(aFile);
 		}
 		return result;
 	}

 	private File getNestedJARFromSourceFolder(IFolder folder) {
 		List sourceIFiles = new ArrayList();
 		boolean isModuleRoot = folder.equals(moduleRoot);
 		boolean foundJava = gatherFilesForJAR(sourceIFiles, folder, folder, isModuleRoot, false);
 		if (!isModuleRoot || foundJava) {
 			return createNestedArchive(sourceIFiles, folder);
 		}
 		return null;
 	}

 	private File createNestedArchive(List sourceIFiles, IFolder folder) {
 		NestedJARLoadStrategyImpl loader = new NestedJARLoadStrategyImpl(this, sourceIFiles, folder);
 		loader.setExportSource(isExportSource());
 		ArchiveOptions options = ((Archive) getContainer()).getOptions().cloneWith(loader);
 		String uri = computeUniqueArchiveURI(folder);
 		try {
 			return getArchiveFactory().primOpenArchive(options, uri);
 		} catch (OpenFailureException ex) {
 			throw new ArchiveRuntimeException(ex);
 		}
 	}

 	private String computeUniqueArchiveURI(IFolder folder) {
 		int increment = 0;
 		String name = folder.getName();
 		StringBuffer sb = null;
 		do {
 			sb = new StringBuffer(name.length() + 5);
 			sb.append('_');
 			sb.append(name);
 			if (increment > 0)
 				sb.append(increment);
 			sb.append(".jar"); //$NON-NLS-1$
 			increment++;
 		} while (visitedURIs.contains(sb.toString()));
 		return sb.toString();
 	}

 	private boolean gatherFilesForJAR(List iFiles, IFolder current, IFolder root, boolean isModuleRoot, boolean foundJava) {
 		IResource[] members;
 		try {
 			members = current.members();
 		} catch (CoreException core) {
 			throw new ArchiveRuntimeException(core);
 		}
 		for (int i = 0; i < members.length; i++) {
 			IResource res = members[i];
 			if (res.getType() == IResource.FOLDER) {
 				foundJava = gatherFilesForJAR(iFiles, (IFolder) res, root, isModuleRoot, foundJava) || foundJava;
 			} else {//it must be a file
 				IFile iFile = (IFile) res;
 				checkInnerClass(iFile);
 				if (belongsInNestedJAR(iFile, root, isModuleRoot)) {
 					iFiles.add(iFile);
 					if (isModuleRoot)
 						foundJava = foundJava || isJava(iFile) || isClass(iFile);
 				}
 			}
 		}
 		return foundJava;
 	}

 	private void checkInnerClass(IFile iFile) {
 		if (!isClass(iFile))
 			return;
 		String name = iFile.getName();
 		if (name.indexOf('$') != -1) {
 			if (innerClasses == null)
 				innerClasses = new HashMap();
 			IPath relPath = iFile.getProjectRelativePath().removeFirstSegments(moduleRootSegmentCount);
 			String key = relPath.toString();
 			key = key.substring(0, key.indexOf('$'));
 			List inners = (List) innerClasses.get(key);
 			if (inners == null) {
 				inners = new ArrayList(1);
 				innerClasses.put(key, inners);
 			}
 			inners.add(iFile);
 		}
 	}

 	public List retrieveInnerClasses(String key) {
 		if (innerClasses == null)
 			return null;
 		return (List) innerClasses.get(key);
 	}


 	public boolean isJava(IFile iFile) {
 		return hasExtension(iFile, ArchiveUtil.DOT_JAVA);
 	}

 	public boolean isClass(IFile iFile) {
 		return hasExtension(iFile, ArchiveUtil.DOT_CLASS);
 	}

 	private boolean hasExtension(IFile iFile, String ext) {
 		String name = iFile.getName();
 		return hasExtension(name, ext);
 	}

 	private boolean hasExtension(String name, String ext) {
 		int offset = ext.length();
 		return name.regionMatches(true, name.length() - offset, ext, 0, offset);
 	}

 	/**
 	 * @see org.eclipse.jst.j2ee.internal.internal.internal.archive.operations.J2EELoadStrategyImpl#shouldInclude(String)
 	 */
 	protected boolean shouldInclude(String uri) {
 		return !hasExtension(uri, ArchiveUtil.DOT_CLASS) && !hasExtension(uri, ArchiveUtil.DOT_JAVA);
 	}

 	private boolean belongsInNestedJAR(IFile iFile, IFolder root, boolean isModuleRoot) {
 		for (int i = 0; i < knownLibExtensions.length; i++) {
 			if (hasExtension(iFile, knownLibExtensions[i]) || (isModuleRoot && (isDeploymentDescriptor(iFile, root) || isClassWithSource(iFile))))
 				return false;
 		}
 		return true;
 	}

 	/**
 	 * @param iFile
 	 * @return
 	 */
 	private boolean isClassWithSource(IFile iFile) {
 		return isClass(iFile) && hasSource(iFile);
 	}


 	/**
 	 * @param iFile
 	 * @return
 	 */
 	private boolean hasSource(IFile classFile) {
 		IPath path = classFile.getProjectRelativePath().removeFirstSegments(moduleRootSegmentCount);
 		String baseURI = ArchiveUtil.classUriToJavaUri(path.toString());
 		return moduleRoot.getFile(new Path(baseURI)).exists();
 	}

 	private boolean isDeploymentDescriptor(IFile iFile, IFolder root) {
 		IPath path = iFile.getProjectRelativePath().removeFirstSegments(moduleRootSegmentCount);
 		return J2EEConstants.RAR_DD_URI.equals(path.toString());
 	}

 	public IContainer getModuleContainer() {
 		return moduleRoot;
 	}

 	public IContainer getModuleRoot() {
 		return moduleRoot;
 	}

 	protected void init() {
 		ConnectorNatureRuntime connRT = ConnectorNatureRuntime.getRuntime(getProject());
 		moduleRoot = connRT.getModuleServerRoot();
 		projectURIConverter = new WorkbenchURIConverterImpl(moduleRoot);
 		moduleRootSegmentCount = moduleRoot.getProjectRelativePath().segmentCount();
 	}

 	public WorkbenchURIConverter getProjectURIConverter() {
 		return projectURIConverter;
 	}

 	/**
 	 * Returns the moduleRootSegmentCount.
 	 *
 	 * @return int
 	 */
 	public int getModuleRootSegmentCount() {
 		return moduleRootSegmentCount;
 	}


 }
	/*******************************************************************************
	* Copyright (c) 2003, 2004 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.jca.archive.operations;


	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.core.resources.IContainer;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IFolder;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.jem.util.emf.workbench.WorkbenchURIConverter;
	import org.eclipse.jem.util.emf.workbench.WorkbenchURIConverterImpl;
	import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive;
	import org.eclipse.jst.j2ee.commonarchivecore.internal.File;
	import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.ArchiveRuntimeException;
	import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.OpenFailureException;
	import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveOptions;
	import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveUtil;
	import org.eclipse.jst.j2ee.internal.J2EEConstants;
	import org.eclipse.jst.j2ee.internal.archive.operations.J2EELoadStrategyImpl;
	import org.eclipse.jst.j2ee.internal.jca.operations.ConnectorNatureRuntime;

	/**
	* Class defines the loading mechanism for RAR projects.
	*/
	public class RARProjectLoadStrategyImpl extends J2EELoadStrategyImpl {

	//The module root of the RAR, usually a "connectorModule" folder
	private IContainer moduleRoot;
	private int moduleRootSegmentCount;
	private Map innerClasses;

	public static String[] knownLibExtensions = {".jar", //$NON-NLS-1$
	".zip", //$NON-NLS-1$
	".so", //$NON-NLS-1$
	".o", //$NON-NLS-1$
	".sl", //$NON-NLS-1$
	".dll", //$NON-NLS-1$
	}; //$NON-NLS-1$

	public RARProjectLoadStrategyImpl(IProject aProject) {
	super();
	project = aProject;
	filesList = new ArrayList();
	init();
	}

	/**
	* @see org.eclipse.jst.j2ee.internal.internal.internal.archive.operations.J2EELoadStrategyImpl#getFiles()
	*/
	public List getFiles() {
	List files = super.getFiles();
	files.addAll(getNestedJARsFromSourceFolders());
	return files;
	}

	/**
	* @see org.eclipse.jst.j2ee.internal.internal.internal.archive.operations.J2EELoadStrategyImpl#getFiles(List)
	*/
	protected ArrayList getFiles(List projectResources) throws Exception {
	return super.getFiles(projectResources);
	}

	/**
	* @see org.eclipse.jst.j2ee.internal.internal.internal.archive.operations.J2EELoadStrategyImpl#shouldInclude(IContainer)
	*/
	protected boolean shouldInclude(IContainer iContainer) {
	return moduleRoot.equals(iContainer) \|\| !getSourceFolders().contains(iContainer);
	}

	private Collection getNestedJARsFromSourceFolders() {
	List localSourceFolders = getSourceFolders();
	List result = new ArrayList(localSourceFolders.size());
	for (int i = 0; i < localSourceFolders.size(); i++) {
	IFolder folder = (IFolder) localSourceFolders.get(i);
	File aFile = getNestedJARFromSourceFolder(folder);
	if (aFile != null)
	result.add(aFile);
	}
	return result;
	}

	private File getNestedJARFromSourceFolder(IFolder folder) {
	List sourceIFiles = new ArrayList();
	boolean isModuleRoot = folder.equals(moduleRoot);
	boolean foundJava = gatherFilesForJAR(sourceIFiles, folder, folder, isModuleRoot, false);
	if (!isModuleRoot \|\| foundJava) {
	return createNestedArchive(sourceIFiles, folder);
	}
	return null;
	}

	private File createNestedArchive(List sourceIFiles, IFolder folder) {
	NestedJARLoadStrategyImpl loader = new NestedJARLoadStrategyImpl(this, sourceIFiles, folder);
	loader.setExportSource(isExportSource());
	ArchiveOptions options = ((Archive) getContainer()).getOptions().cloneWith(loader);
	String uri = computeUniqueArchiveURI(folder);
	try {
	return getArchiveFactory().primOpenArchive(options, uri);
	} catch (OpenFailureException ex) {
	throw new ArchiveRuntimeException(ex);
	}
	}

	private String computeUniqueArchiveURI(IFolder folder) {
	int increment = 0;
	String name = folder.getName();
	StringBuffer sb = null;
	do {
	sb = new StringBuffer(name.length() + 5);
	sb.append('_');
	sb.append(name);
	if (increment > 0)
	sb.append(increment);
	sb.append(".jar"); //$NON-NLS-1$
	increment++;
	} while (visitedURIs.contains(sb.toString()));
	return sb.toString();
	}

	private boolean gatherFilesForJAR(List iFiles, IFolder current, IFolder root, boolean isModuleRoot, boolean foundJava) {
	IResource[] members;
	try {
	members = current.members();
	} catch (CoreException core) {
	throw new ArchiveRuntimeException(core);
	}
	for (int i = 0; i < members.length; i++) {
	IResource res = members[i];
	if (res.getType() == IResource.FOLDER) {
	foundJava = gatherFilesForJAR(iFiles, (IFolder) res, root, isModuleRoot, foundJava) \|\| foundJava;
	} else {//it must be a file
	IFile iFile = (IFile) res;
	checkInnerClass(iFile);
	if (belongsInNestedJAR(iFile, root, isModuleRoot)) {
	iFiles.add(iFile);
	if (isModuleRoot)
	foundJava = foundJava \|\| isJava(iFile) \|\| isClass(iFile);
	}
	}
	}
	return foundJava;
	}

	private void checkInnerClass(IFile iFile) {
	if (!isClass(iFile))
	return;
	String name = iFile.getName();
	if (name.indexOf('$') != -1) {
	if (innerClasses == null)
	innerClasses = new HashMap();
	IPath relPath = iFile.getProjectRelativePath().removeFirstSegments(moduleRootSegmentCount);
	String key = relPath.toString();
	key = key.substring(0, key.indexOf('$'));
	List inners = (List) innerClasses.get(key);
	if (inners == null) {
	inners = new ArrayList(1);
	innerClasses.put(key, inners);
	}
	inners.add(iFile);
	}
	}

	public List retrieveInnerClasses(String key) {
	if (innerClasses == null)
	return null;
	return (List) innerClasses.get(key);
	}


	public boolean isJava(IFile iFile) {
	return hasExtension(iFile, ArchiveUtil.DOT_JAVA);
	}

	public boolean isClass(IFile iFile) {
	return hasExtension(iFile, ArchiveUtil.DOT_CLASS);
	}

	private boolean hasExtension(IFile iFile, String ext) {
	String name = iFile.getName();
	return hasExtension(name, ext);
	}

	private boolean hasExtension(String name, String ext) {
	int offset = ext.length();
	return name.regionMatches(true, name.length() - offset, ext, 0, offset);
	}

	/**
	* @see org.eclipse.jst.j2ee.internal.internal.internal.archive.operations.J2EELoadStrategyImpl#shouldInclude(String)
	*/
	protected boolean shouldInclude(String uri) {
	return !hasExtension(uri, ArchiveUtil.DOT_CLASS) && !hasExtension(uri, ArchiveUtil.DOT_JAVA);
	}

	private boolean belongsInNestedJAR(IFile iFile, IFolder root, boolean isModuleRoot) {
	for (int i = 0; i < knownLibExtensions.length; i++) {
	if (hasExtension(iFile, knownLibExtensions[i]) \|\| (isModuleRoot && (isDeploymentDescriptor(iFile, root) \|\| isClassWithSource(iFile))))
	return false;
	}
	return true;
	}

	/**
	* @param iFile
	* @return
	*/
	private boolean isClassWithSource(IFile iFile) {
	return isClass(iFile) && hasSource(iFile);
	}


	/**
	* @param iFile
	* @return
	*/
	private boolean hasSource(IFile classFile) {
	IPath path = classFile.getProjectRelativePath().removeFirstSegments(moduleRootSegmentCount);
	String baseURI = ArchiveUtil.classUriToJavaUri(path.toString());
	return moduleRoot.getFile(new Path(baseURI)).exists();
	}

	private boolean isDeploymentDescriptor(IFile iFile, IFolder root) {
	IPath path = iFile.getProjectRelativePath().removeFirstSegments(moduleRootSegmentCount);
	return J2EEConstants.RAR_DD_URI.equals(path.toString());
	}

	public IContainer getModuleContainer() {
	return moduleRoot;
	}

	public IContainer getModuleRoot() {
	return moduleRoot;
	}

	protected void init() {
	ConnectorNatureRuntime connRT = ConnectorNatureRuntime.getRuntime(getProject());
	moduleRoot = connRT.getModuleServerRoot();
	projectURIConverter = new WorkbenchURIConverterImpl(moduleRoot);
	moduleRootSegmentCount = moduleRoot.getProjectRelativePath().segmentCount();
	}

	public WorkbenchURIConverter getProjectURIConverter() {
	return projectURIConverter;
	}

	/**
	* Returns the moduleRootSegmentCount.
	*
	* @return int
	*/
	public int getModuleRootSegmentCount() {
	return moduleRootSegmentCount;
	}


	}