Java tutorial
/******************************************************************************* * Copyright (c) 2006 Sybase, Inc. 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: * Sybase, Inc. - initial API and implementation *******************************************************************************/ package org.eclipse.jst.jsf.common.ui.internal.utils; import java.io.File; import java.util.StringTokenizer; 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.IPath; import org.eclipse.core.runtime.Path; import org.eclipse.jdt.core.IClasspathEntry; import org.eclipse.jdt.core.IJarEntryResource; import org.eclipse.jdt.core.IJavaElement; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jst.jsf.common.ui.IFileFolderConstants; import org.eclipse.ui.IFileEditorInput; import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.IWorkbenchWindow; import org.eclipse.ui.PlatformUI; /** * Collection of helper methods to manage and convert links Originally part of * the LinksManager (com.ibm.iwt.parser.util) */ public final class PathUtil { private static final String FORWARD_SLASH = "/"; //$NON-NLS-1$ private static final String RELATIVE_PATH_SIGNAL = IFileFolderConstants.DOT + IFileFolderConstants.DOT + IFileFolderConstants.PATH_SEPARATOR; /** * adjust relative path isside the absolute path * @param path * @return the adjusted path */ public static String adjustPath(String path) { int i = 0; while ((i = path.indexOf(RELATIVE_PATH_SIGNAL)) > 0) { // split the string into two String part1 = path.substring(0, i - 1); String part2 = path.substring(i + RELATIVE_PATH_SIGNAL.length() - 1); // strip one path seg from part1 int j = part1.lastIndexOf(FORWARD_SLASH); if (j == -1) { return "";//$NON-NLS-1$ } part1 = part1.substring(0, j); path = part1 + part2; } return path; } /** * Append trailing url slash if needed * @param input * @return the string */ public static String appendTrailingURLSlash(String input) { // check to see already a slash if (!input.endsWith(FORWARD_SLASH)) { input += FORWARD_SLASH; } return input; } /** * Convert to relative url based on base * @param input * @param base * @return the string */ public static String convertToRelativePath(String input, String base) { // tokenize the strings StringTokenizer inputTokenizer = new StringTokenizer(input, FORWARD_SLASH); StringTokenizer baseTokenizer = new StringTokenizer(base, FORWARD_SLASH); String token1 = "", token2 = "";//$NON-NLS-2$//$NON-NLS-1$ // // Go through until equls while (true) { if (!inputTokenizer.hasMoreTokens() || !baseTokenizer.hasMoreTokens()) { break; } token1 = baseTokenizer.nextToken(); token2 = inputTokenizer.nextToken(); if (!token1.equals(token2)) { break; } } // now generate the backs String output = "";//$NON-NLS-1$ while (baseTokenizer.hasMoreTokens()) { baseTokenizer.nextToken(); output += RELATIVE_PATH_SIGNAL; } output += token2; // generate the rest while (inputTokenizer.hasMoreTokens()) { output = output + FORWARD_SLASH + inputTokenizer.nextToken(); } return output; } /** * @param projectName * @param path * @return the path in the project converted to a path relative to the * web folder */ public static String convertToWebPath(String projectName, String path) { String name = ""; //$NON-NLS-1$ IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName); String webrootName = WebrootUtil.getWebContentContainer(project).getName(); if (path.indexOf(webrootName) != -1) { name = projectName + IFileFolderConstants.PATH_SEPARATOR + webrootName; } else { name = projectName; } int index = path.indexOf(projectName); return path.substring(index + name.length()); } /** * convert path relative to current active file to absolute path in * filesystem * * @param uri * the relative path * @param curFile * @return absolute path in file system */ public static String convertToAbsolutePath(String uri, IFile curFile) { if (uri == null || uri.trim().equals("")) { //$NON-NLS-1$ return uri; } String webroot = ""; //$NON-NLS-1$ IFile jsp = curFile; try { if (jsp == null) { jsp = ((IFileEditorInput) getActivePage().getActiveEditor().getEditorInput()).getFile(); } if (jsp != null) { String webrootName = WebrootUtil.getWebContentContainer(jsp.getProject()).getName(); webroot = jsp.getProject().getFolder(webrootName).getLocation().toString(); } } catch (NullPointerException e) { return uri; } if (uri.startsWith(IFileFolderConstants.PATH_SEPARATOR)) { return webroot + uri; } if (jsp != null) { IContainer con = jsp.getParent(); if (con != null) { IPath path = con.getLocation(); if (path != null) { String aPath = path.toString() + File.separator + uri; aPath = aPath.replace('/', File.separatorChar); aPath = aPath.replace('\\', File.separatorChar); if (aPath.endsWith(File.separator)) { aPath += IFileFolderConstants.PATH_SEPARATOR; } File file = new File(aPath); if (file.exists() && file.isFile()) { return file.getAbsolutePath(); } return uri; } } } return uri; } /** * Returns the active workbench window. * * @return the active workbench window. this can be null but I've never seen * it. */ private static IWorkbenchWindow getActiveWorkbenchWindow() { if (PlatformUI.getWorkbench() == null) { return null; } return PlatformUI.getWorkbench().getActiveWorkbenchWindow(); } /** * Returns the active workbench page. Note that the active page may not be * the one that the user perceives as active in some situations so this * method of obtaining the activate page should only be used if no other * method is available. * * @return the active workbench page */ private static IWorkbenchPage getActivePage() { IWorkbenchWindow window = getActiveWorkbenchWindow(); if (window == null) { return null; } return window.getActivePage(); } /** * @param javaProject * @param parent * @return the IPath for a a classpath object (?) */ public static IPath getPathOnClasspath(IJavaProject javaProject, Object parent) { IPath result = null; if (javaProject == null || parent == null) { return new Path(""); //$NON-NLS-1$ } IClasspathEntry[] entries = javaProject.readRawClasspath(); IPath classPath = null; if (parent instanceof IResource) { if (((javaProject != null) && !javaProject.isOnClasspath((IResource) parent))) { return new Path(""); //$NON-NLS-1$ } if (parent instanceof IFile) { IPath elementPath = ((IFile) parent).getFullPath(); if (((IFile) parent).getFileExtension().equalsIgnoreCase(IFileFolderConstants.EXT_PROPERTIES)) { int machings = 0; try { for (int i = 0; i < entries.length; i++) { // Determine whether on this classentry's path int n = entries[i].getPath().matchingFirstSegments(elementPath); if (n > machings) { // Get package name machings = n; classPath = elementPath.removeFirstSegments(machings).removeLastSegments(1); } } // Not on the classpath? if (classPath == null) { return null; } else if (classPath.segmentCount() > 0) { IJavaElement element = javaProject.findElement(classPath); if (element != null) { IPath path = element.getPath(); if (path != null) { IPath path1 = path.removeFirstSegments(machings); String fileName = ((IFile) parent).getName(); if (fileName != null) { result = path1.append(fileName); } } } } else { result = ((IFile) parent).getFullPath().removeFirstSegments(machings); } } catch (Exception e) { return null; } } } } else if (parent instanceof IJarEntryResource) { IPath elementPath = ((IJarEntryResource) parent).getFullPath(); if (elementPath.getFileExtension().equalsIgnoreCase(IFileFolderConstants.EXT_PROPERTIES)) { result = elementPath; } } if (result != null) { return result; } return new Path(""); //$NON-NLS-1$ } private PathUtil() { // utility class, no instantiation } }