org.cloudsmith.geppetto.ui.wizard.ModuleExportOperation.java Source code

Introduction

Here is the source code for org.cloudsmith.geppetto.ui.wizard.ModuleExportOperation.java

Source

/**
 * Copyright (c) 2011 Cloudsmith Inc. and other contributors, as listed below.
 * 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:
 *   Cloudsmith
 * 
 */
package org.cloudsmith.geppetto.ui.wizard;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.cloudsmith.geppetto.forge.Forge;
import org.cloudsmith.geppetto.ui.UIPlugin;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.dialogs.IOverwriteQuery;
import org.eclipse.ui.internal.wizards.datatransfer.DataTransferMessages;

public abstract class ModuleExportOperation implements IRunnableWithProgress {
    static class ExportSpec {
        private final File moduleDirectory;

        private final FileFilter fileFilter;

        ExportSpec(File moduleRoot, FileFilter fileFilter) {
            this.moduleDirectory = moduleRoot;
            this.fileFilter = fileFilter;
        }

        FileFilter getFileFilter() {
            return fileFilter;
        }

        File getModuleRoot() {
            return moduleDirectory;
        }
    }

    public static class ResourceFileFilter implements FileFilter {
        private final FileFilter defaultFilter;

        private final List<File> acceptedFiles;

        public ResourceFileFilter(Collection<IResource> resources, FileFilter defaultFilter) {
            this.defaultFilter = defaultFilter;
            acceptedFiles = new ArrayList<File>(resources.size());
            for (IResource resource : resources)
                acceptedFiles.add(resource.getLocation().toFile());
        }

        @Override
        public boolean accept(File file) {
            return defaultFilter.accept(file) && acceptedFiles.contains(file);
        }
    }

    private final List<ExportSpec> exportSpecs;

    private final File destination;

    private final List<IStatus> errorTable = new ArrayList<IStatus>();

    public ModuleExportOperation(List<ExportSpec> exportSpecs, File destination,
            IOverwriteQuery overwriteImplementor) {
        this.exportSpecs = exportSpecs;
        this.destination = destination;
    }

    protected File getDestination() {
        return destination;
    }

    protected abstract Forge getForge();

    public IStatus getStatus() {
        if (errorTable.isEmpty())
            return Status.OK_STATUS;
        if (errorTable.size() == 1)
            return errorTable.get(0);
        return new MultiStatus(errorTable.get(0).getPlugin(), 0, errorTable.toArray(new IStatus[errorTable.size()]),
                DataTransferMessages.FileSystemExportOperation_problemsExporting, null);
    }

    public void run(IProgressMonitor monitor) throws InterruptedException {
        monitor.beginTask(null, 100);
        try {
            List<String> subtaskNames = new ArrayList<String>(exportSpecs.size());
            for (ExportSpec spec : exportSpecs)
                subtaskNames.add("Building module " + spec.getModuleRoot().getPath());

            DiagnosticWithProgress diagWithProgress = new DiagnosticWithProgress(monitor, 100, subtaskNames, 200);
            for (ExportSpec spec : exportSpecs) {
                if (monitor.isCanceled())
                    throw new OperationCanceledException();
                try {
                    getForge().build(spec.getModuleRoot(), destination, spec.getFileFilter(), null,
                            diagWithProgress);
                    diagWithProgress.taskDone();
                } catch (IOException e) {
                    errorTable.add(UIPlugin.createStatus(IStatus.ERROR,
                            NLS.bind(DataTransferMessages.DataTransfer_errorExporting,
                                    spec.getModuleRoot().getAbsoluteFile(), e.getMessage()),
                            e));
                }
            }
            diagWithProgress.done();
        } finally {
            monitor.done();
        }
    }
}