Java tutorial
/******************************************************************************* * Copyright (c) 2000, 2011 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.ui.internal.wizards.datatransfer; import java.io.IOException; import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import org.eclipse.core.resources.IContainer; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IResource; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.MultiStatus; import org.eclipse.core.runtime.Status; import org.eclipse.jface.operation.IRunnableWithProgress; import org.eclipse.jface.operation.ModalContext; import org.eclipse.osgi.util.NLS; import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin; /** * Operation for exporting a resource and its children to a new .zip or * .tar.gz file. * * @since 3.1 */ public class ArchiveFileExportOperation implements IRunnableWithProgress { private IFileExporter exporter; private String destinationFilename; private IProgressMonitor monitor; private List resourcesToExport; private IResource resource; private List errorTable = new ArrayList(1); //IStatus private boolean useCompression = true; private boolean useTarFormat = false; private boolean createLeadupStructure = true; /** * Create an instance of this class. Use this constructor if you wish to * export specific resources without a common parent resource * * @param resources java.util.Vector * @param filename java.lang.String */ public ArchiveFileExportOperation(List resources, String filename) { super(); // Eliminate redundancies in list of resources being exported Iterator elementsEnum = resources.iterator(); while (elementsEnum.hasNext()) { IResource currentResource = (IResource) elementsEnum.next(); if (isDescendent(resources, currentResource)) { elementsEnum.remove(); //Removes currentResource; } } resourcesToExport = resources; destinationFilename = filename; } /** * Create an instance of this class. Use this constructor if you wish * to recursively export a single resource. * * @param res org.eclipse.core.resources.IResource; * @param filename java.lang.String */ public ArchiveFileExportOperation(IResource res, String filename) { super(); resource = res; destinationFilename = filename; } /** * Create an instance of this class. Use this constructor if you wish to * export specific resources with a common parent resource (affects container * directory creation) * * @param res org.eclipse.core.resources.IResource * @param resources java.util.Vector * @param filename java.lang.String */ public ArchiveFileExportOperation(IResource res, List resources, String filename) { this(res, filename); resourcesToExport = resources; } /** * Add a new entry to the error table with the passed information */ protected void addError(String message, Throwable e) { errorTable.add(new Status(IStatus.ERROR, IDEWorkbenchPlugin.IDE_WORKBENCH, 0, message, e)); } /** * Answer the total number of file resources that exist at or below self * in the resources hierarchy. * * @return int * @param checkResource org.eclipse.core.resources.IResource */ protected int countChildrenOf(IResource checkResource) throws CoreException { if (checkResource.getType() == IResource.FILE) { return 1; } int count = 0; if (checkResource.isAccessible()) { IResource[] children = ((IContainer) checkResource).members(); for (int i = 0; i < children.length; i++) { count += countChildrenOf(children[i]); } } return count; } /** * Answer a boolean indicating the number of file resources that were * specified for export * * @return int */ protected int countSelectedResources() throws CoreException { int result = 0; Iterator resources = resourcesToExport.iterator(); while (resources.hasNext()) { result += countChildrenOf((IResource) resources.next()); } return result; } /** * Export the passed resource to the destination .zip. Export with * no path leadup * * @param exportResource org.eclipse.core.resources.IResource */ protected void exportResource(IResource exportResource) throws InterruptedException { exportResource(exportResource, 1); } /** * Creates and returns the string that should be used as the name of the entry in the archive. * @param exportResource the resource to export * @param leadupDepth the number of resource levels to be included in the path including the resourse itself. */ private String createDestinationName(int leadupDepth, IResource exportResource) { IPath fullPath = exportResource.getFullPath(); if (createLeadupStructure) { return fullPath.makeRelative().toString(); } return fullPath.removeFirstSegments(fullPath.segmentCount() - leadupDepth).toString(); } /** * Export the passed resource to the destination .zip * * @param exportResource org.eclipse.core.resources.IResource * @param leadupDepth the number of resource levels to be included in * the path including the resourse itself. */ protected void exportResource(IResource exportResource, int leadupDepth) throws InterruptedException { if (!exportResource.isAccessible()) { return; } if (exportResource.getType() == IResource.FILE) { String destinationName = createDestinationName(leadupDepth, exportResource); monitor.subTask(destinationName); try { exporter.write((IFile) exportResource, destinationName); } catch (IOException e) { addError(NLS.bind(DataTransferMessages.DataTransfer_errorExporting, exportResource.getFullPath().makeRelative(), e.getMessage()), e); } catch (CoreException e) { addError(NLS.bind(DataTransferMessages.DataTransfer_errorExporting, exportResource.getFullPath().makeRelative(), e.getMessage()), e); } monitor.worked(1); ModalContext.checkCanceled(monitor); } else { IResource[] children = null; try { children = ((IContainer) exportResource).members(); } catch (CoreException e) { // this should never happen because an #isAccessible check is done before #members is invoked addError(NLS.bind(DataTransferMessages.DataTransfer_errorExporting, exportResource.getFullPath()), e); } if (children.length == 0) { // create an entry for empty containers, see bug 278402 String destinationName = createDestinationName(leadupDepth, exportResource); try { exporter.write((IContainer) exportResource, destinationName + IPath.SEPARATOR); } catch (IOException e) { addError(NLS.bind(DataTransferMessages.DataTransfer_errorExporting, exportResource.getFullPath().makeRelative(), e.getMessage()), e); } } for (int i = 0; i < children.length; i++) { exportResource(children[i], leadupDepth + 1); } } } /** * Export the resources contained in the previously-defined * resourcesToExport collection */ protected void exportSpecifiedResources() throws InterruptedException { Iterator resources = resourcesToExport.iterator(); while (resources.hasNext()) { IResource currentResource = (IResource) resources.next(); exportResource(currentResource); } } /** * Returns the status of the operation. * If there were any errors, the result is a status object containing * individual status objects for each error. * If there were no errors, the result is a status object with error code <code>OK</code>. * * @return the status */ public IStatus getStatus() { IStatus[] errors = new IStatus[errorTable.size()]; errorTable.toArray(errors); return new MultiStatus(IDEWorkbenchPlugin.IDE_WORKBENCH, IStatus.OK, errors, DataTransferMessages.FileSystemExportOperation_problemsExporting, null); } /** * Initialize this operation * * @exception java.io.IOException */ protected void initialize() throws IOException { if (useTarFormat) { exporter = new TarFileExporter(destinationFilename, useCompression); } else { exporter = new ZipFileExporter(destinationFilename, useCompression); } } /** * Answer a boolean indicating whether the passed child is a descendent * of one or more members of the passed resources collection * * @return boolean * @param resources java.util.Vector * @param child org.eclipse.core.resources.IResource */ protected boolean isDescendent(List resources, IResource child) { if (child.getType() == IResource.PROJECT) { return false; } IResource parent = child.getParent(); if (resources.contains(parent)) { return true; } return isDescendent(resources, parent); } /** * Export the resources that were previously specified for export * (or if a single resource was specified then export it recursively) */ public void run(IProgressMonitor progressMonitor) throws InvocationTargetException, InterruptedException { this.monitor = progressMonitor; try { initialize(); } catch (IOException e) { throw new InvocationTargetException(e, NLS.bind(DataTransferMessages.ZipExport_cannotOpen, e.getMessage())); } try { // ie.- a single resource for recursive export was specified int totalWork = IProgressMonitor.UNKNOWN; try { if (resourcesToExport == null) { totalWork = countChildrenOf(resource); } else { totalWork = countSelectedResources(); } } catch (CoreException e) { // Should not happen } monitor.beginTask(DataTransferMessages.DataTransfer_exportingTitle, totalWork); if (resourcesToExport == null) { exportResource(resource); } else { // ie.- a list of specific resources to export was specified exportSpecifiedResources(); } try { exporter.finished(); } catch (IOException e) { throw new InvocationTargetException(e, NLS.bind(DataTransferMessages.ZipExport_cannotClose, e.getMessage())); } } finally { monitor.done(); } } /** * Set this boolean indicating whether each exported resource's path should * include containment hierarchies as dictated by its parents * * @param value boolean */ public void setCreateLeadupStructure(boolean value) { createLeadupStructure = value; } /** * Set this boolean indicating whether exported resources should * be compressed (as opposed to simply being stored) * * @param value boolean */ public void setUseCompression(boolean value) { useCompression = value; } /** * Set this boolean indicating whether the file should be output * in tar.gz format rather than .zip format. * * @param value boolean */ public void setUseTarFormat(boolean value) { useTarFormat = value; } }