| /******************************************************************************* |
| * Copyright (c) 2010 BSI Business Systems Integration AG. |
| * 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: |
| * BSI Business Systems Integration AG - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.scout.sdk.util.resources; |
| |
| import java.awt.Desktop; |
| import java.io.BufferedInputStream; |
| import java.io.BufferedOutputStream; |
| import java.io.BufferedReader; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.OutputStream; |
| import java.net.URI; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipInputStream; |
| import java.util.zip.ZipOutputStream; |
| |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceProxy; |
| import org.eclipse.core.resources.IResourceProxyVisitor; |
| import org.eclipse.core.resources.ProjectScope; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.preferences.IScopeContext; |
| import org.eclipse.jdt.core.IOpenable; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.internal.core.util.Util; |
| import org.eclipse.jface.text.Document; |
| import org.eclipse.osgi.service.datalocation.Location; |
| import org.eclipse.scout.commons.FileUtility; |
| import org.eclipse.scout.commons.IOUtility; |
| import org.eclipse.scout.sdk.util.internal.SdkUtilActivator; |
| import org.eclipse.scout.sdk.util.log.ScoutStatus; |
| |
| /** |
| * <h3>{@link ResourceUtility}</h3> ... |
| * |
| * @author Andreas Hoegger |
| * @since 3.8.0 14.03.2012 |
| */ |
| @SuppressWarnings("restriction") |
| public final class ResourceUtility { |
| |
| public final static int BUF_SIZE = 8192; |
| |
| private ResourceUtility() { |
| } |
| |
| public static IResource[] getAllResources(IResourceFilter filter) throws CoreException { |
| return getAllResources(ResourcesPlugin.getWorkspace().getRoot(), filter); |
| } |
| |
| public static IResource[] getAllResources(IResource startResource, final IResourceFilter filter) throws CoreException { |
| final List<IResource> collector = new LinkedList<IResource>(); |
| startResource.accept(new IResourceProxyVisitor() { |
| @Override |
| public boolean visit(IResourceProxy proxy) throws CoreException { |
| if (proxy.isAccessible()) { |
| if (filter.accept(proxy)) { |
| collector.add(proxy.requestResource()); |
| } |
| return true; |
| } |
| return false; |
| } |
| }, IResource.NONE); |
| |
| return collector.toArray(new IResource[collector.size()]); |
| } |
| |
| /** |
| * Tries to open the given url in the system default browser. |
| * |
| * @param url |
| * the url to show |
| */ |
| public static void showUrlInBrowser(String url) { |
| try { |
| if (Desktop.isDesktopSupported()) { |
| Desktop d = Desktop.getDesktop(); |
| if (d.isSupported(Desktop.Action.BROWSE)) { |
| d.browse(new URI(url)); |
| } |
| } |
| } |
| catch (Throwable e) { |
| SdkUtilActivator.logWarning("Could not open web browser. ", e); |
| } |
| } |
| |
| public static boolean exists(IResource resource) { |
| return resource != null && resource.exists(); |
| } |
| |
| /** |
| * Builds a Path containing the given elements. |
| * |
| * @param segments |
| * @return |
| */ |
| public static IPath toPath(String... segments) { |
| IPath path = null; |
| if (segments != null) { |
| if (segments.length > 0) { |
| path = new Path(segments[0]); |
| for (int i = 1; i < segments.length; i++) { |
| path = path.append(new Path(segments[i])); |
| } |
| } |
| } |
| return path; |
| } |
| |
| /** |
| * Returns this document's default line delimiter. |
| * <p> |
| * This default line delimiter should be used by clients who want unique delimiters (e.g. 'CR's) in the document. |
| * </p> |
| * |
| * @return the default line delimiter or <code>null</code> if none. |
| */ |
| public static String getLineSeparator(Document doc) { |
| if (doc != null) { |
| String delim = doc.getDefaultLineDelimiter(); |
| if (delim != null) { |
| return delim; |
| } |
| } |
| return getLineSeparator(); |
| } |
| |
| /** |
| * Gets the content of the given file as string. |
| * |
| * @param f |
| * the file to get the content from |
| * @return a string containing the content of the given file |
| */ |
| public static String getContent(IFile f) throws CoreException { |
| BufferedReader reader = null; |
| try { |
| reader = new BufferedReader(new InputStreamReader(f.getContents())); |
| StringBuilder sb = new StringBuilder(); |
| String line = null; |
| String nl = getLineSeparator(f); |
| while ((line = reader.readLine()) != null) { |
| sb.append(line); |
| sb.append(nl); |
| } |
| return sb.toString(); |
| } |
| catch (IOException e) { |
| throw new CoreException(new ScoutStatus(e)); |
| } |
| finally { |
| if (reader != null) { |
| try { |
| reader.close(); |
| } |
| catch (IOException e) { |
| //nop |
| } |
| } |
| } |
| } |
| |
| /** |
| * gets the install location of the running eclipse. |
| * |
| * @return the location or null if no location could be found. |
| */ |
| public static File getEclipseInstallLocation() { |
| Location l = Platform.getInstallLocation(); |
| File ret = null; |
| if (l != null) { |
| ret = new File(l.getURL().getPath()); |
| } |
| return ret; |
| } |
| |
| /** |
| * Adds all files below the given baseDir into the zip stream. |
| * |
| * @param baseDir |
| * The base dir. All files (recursively) in this folder will be added to the zip. |
| * @param zOut |
| * The zip where the files will be added. |
| * @throws IOException |
| */ |
| public static void addFolderToZip(File baseDir, ZipOutputStream zOut) throws IOException { |
| addFolderToZipRec(baseDir, baseDir, zOut); |
| } |
| |
| private static void addFolderToZipRec(File baseDir, File file, ZipOutputStream zOut) throws IOException { |
| if ((!file.exists()) || (!file.isDirectory())) { |
| throw new IOException("source directory " + file + " does not exist or is not a folder"); |
| } |
| for (File f : file.listFiles()) { |
| if (f.exists() && (!f.isHidden())) { |
| if (f.isDirectory()) { |
| addFolderToZipRec(baseDir, f, zOut); |
| } |
| else { |
| String name = f.getAbsolutePath(); |
| String prefix = baseDir.getAbsolutePath(); |
| if (prefix.endsWith("/") || prefix.endsWith("\\")) { |
| prefix = prefix.substring(0, prefix.length() - 1); |
| } |
| name = name.substring(prefix.length() + 1); |
| name = name.replace('\\', '/'); |
| |
| zOut.putNextEntry(new ZipEntry(name)); |
| copy(f, zOut); |
| zOut.closeEntry(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * returns the line separator defined in preference {@link org.eclipse.core.runtime.Platform#PREF_LINE_SEPARATOR} on |
| * the workspace. |
| * If this is null, returns the system line separator. |
| * |
| * @return The line separator to use. |
| */ |
| public static String getLineSeparator() { |
| return Util.getLineSeparator(null, null); |
| } |
| |
| /** |
| * returns the line separator defined in preference {@link org.eclipse.core.runtime.Platform#PREF_LINE_SEPARATOR} on |
| * the project or workspace of the given resource. |
| * If this is null, returns the platform separator. |
| * |
| * @return The line separator to use. |
| */ |
| public static String getLineSeparator(IResource r) { |
| if (r != null) { |
| IScopeContext[] scopeContext = new IScopeContext[]{new ProjectScope(r.getProject())}; |
| String lineSeparator = Platform.getPreferencesService().getString(Platform.PI_RUNTIME, Platform.PREF_LINE_SEPARATOR, null, scopeContext); |
| if (lineSeparator != null) return lineSeparator; |
| } |
| return getLineSeparator(); |
| } |
| |
| /** |
| * Finds and returns the recommended line separator for this element. |
| * The element's buffer is first searched and the first line separator in this buffer is returned if any. |
| * Otherwise the preference {@link org.eclipse.core.runtime.Platform#PREF_LINE_SEPARATOR} on this element's project or |
| * workspace is returned. |
| * Finally if no such preference is set, the system line separator is returned. |
| * |
| * @return the recommended line separator for this element |
| */ |
| public static String getLineSeparator(IOpenable o) { |
| try { |
| return o.findRecommendedLineSeparator(); |
| } |
| catch (JavaModelException e) { |
| return getLineSeparator(); |
| } |
| } |
| |
| /** |
| * copies all data from the given file to the output stream |
| * |
| * @param from |
| * source file |
| * @param to |
| * data target |
| * @throws IOException |
| */ |
| public static void copy(File from, OutputStream to) throws IOException { |
| InputStream input = null; |
| try { |
| input = new BufferedInputStream(new FileInputStream(from), BUF_SIZE); |
| copy(input, to); |
| } |
| finally { |
| if (input != null) { |
| try { |
| input.close(); |
| } |
| catch (IOException e) { |
| } |
| } |
| } |
| } |
| |
| /** |
| * recursively creates all parent directories of the given file |
| * |
| * @param toCreate |
| * The file for which the parent directories should be created. |
| * @param monitor |
| * @throws CoreException |
| */ |
| public static void mkdirs(IFile toCreate, IProgressMonitor monitor) throws CoreException { |
| if (toCreate == null || toCreate.exists()) { |
| return; |
| } |
| mkdirs(toCreate.getParent(), monitor); |
| } |
| |
| /** |
| * create the given directory and all of its parents. |
| * |
| * @param toCreate |
| * the directory to create. |
| * @param monitor |
| * @throws CoreException |
| */ |
| public static void mkdirs(IContainer toCreate, IProgressMonitor monitor) throws CoreException { |
| if (toCreate == null || toCreate.exists()) { |
| return; |
| } |
| else { |
| IContainer parent = toCreate.getParent(); |
| if (parent instanceof IFolder) { |
| mkdirs(parent, monitor); |
| } |
| if (toCreate instanceof IFolder) { |
| ((IFolder) toCreate).create(true, true, monitor); |
| } |
| } |
| } |
| |
| /** |
| * move the given file into the given folder. |
| * |
| * @param from |
| * the file to move |
| * @param destFolder |
| * the destination folder. |
| * @throws IOException |
| */ |
| public static void moveFile(File from, File destFolder) throws IOException { |
| if (from == null || !from.isFile()) { |
| throw new IOException("source file is not valid"); |
| } |
| if (destFolder == null) { |
| throw new IOException("destination folder is not valid"); |
| } |
| destFolder.mkdirs(); |
| boolean success = from.renameTo(destFolder); |
| if (!success) { |
| // fallback: copy file |
| FileUtility.copyFile(from, new File(destFolder, from.getName())); |
| IOUtility.deleteFile(from.getAbsolutePath()); |
| } |
| } |
| |
| public static void extractZip(File zipFile, File destinationFolder) throws IOException { |
| ZipInputStream zipInputStream = null; |
| ZipEntry zipEntry; |
| try { |
| zipInputStream = new ZipInputStream(new BufferedInputStream(new FileInputStream(zipFile))); |
| zipEntry = zipInputStream.getNextEntry(); |
| while (zipEntry != null) { |
| if (!zipEntry.isDirectory()) { |
| String entryName = zipEntry.getName(); |
| |
| File destFile = new File(destinationFolder, entryName); |
| destFile.getParentFile().mkdirs(); |
| OutputStream fos = null; |
| try { |
| fos = new BufferedOutputStream(new FileOutputStream(destFile)); |
| copy(zipInputStream, fos); |
| } |
| finally { |
| if (fos != null) { |
| try { |
| fos.close(); |
| } |
| catch (Exception e) { |
| } |
| } |
| } |
| } |
| zipInputStream.closeEntry(); |
| zipEntry = zipInputStream.getNextEntry(); |
| } |
| } |
| finally { |
| if (zipInputStream != null) { |
| try { |
| zipInputStream.close(); |
| } |
| catch (Exception e) { |
| } |
| } |
| } |
| } |
| |
| /** |
| * copies all data from the input stream to the output stream. |
| * |
| * @param from |
| * data source |
| * @param to |
| * data target |
| * @throws IOException |
| */ |
| public static void copy(InputStream from, OutputStream to) throws IOException { |
| copy(from, to, BUF_SIZE); |
| } |
| |
| /** |
| * copies all data from the input stream to the output stream. |
| * |
| * @param from |
| * data source |
| * @param to |
| * data target |
| * @param bufferSize |
| * buffer size to use |
| * @throws IOException |
| */ |
| public static void copy(InputStream from, OutputStream to, int bufferSize) throws IOException { |
| byte[] b = new byte[bufferSize]; |
| int len; |
| while ((len = from.read(b, 0, b.length)) != -1) { |
| to.write(b, 0, len); |
| } |
| to.flush(); |
| } |
| } |
