| /******************************************************************************* |
| * Copyright (c) 2001, 2007 Oracle 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: |
| * Oracle Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jst.jsf.core.internal.jsflibraryregistry.util; |
| |
| import org.eclipse.core.commands.ExecutionException; |
| import org.eclipse.core.commands.operations.AbstractOperation; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| |
| /** |
| * Implements a single step (vX -> v(X+1)) version upgrade as an |
| * Eclipse operation. Adds an additional "commit" abstract method. This |
| * can be called after execute in situations where further actions require |
| * user approval etc. See the javadocs for the method, it contains important |
| * API rules |
| * |
| * @author cbateman |
| * @deprecated |
| */ |
| public abstract class VersionUpgradeOperation extends AbstractOperation |
| { |
| /** |
| * the version being upgraded from |
| */ |
| protected final int _oldVersion; |
| /** |
| * the version being upgraded to |
| */ |
| protected final int _newVersion; |
| |
| private boolean _hasExecuted; |
| private boolean _hasCommitted; |
| private boolean _hasCleanState = true; |
| |
| /** |
| * @param label |
| * @param oldVersion |
| * @param newVersion |
| */ |
| public VersionUpgradeOperation(String label, int oldVersion, int newVersion) { |
| super(label); |
| _oldVersion = oldVersion; |
| _newVersion = newVersion; |
| } |
| |
| /** |
| * Allows selected functionality to be called after execute is called. |
| * Commit must conform to following contract: |
| * |
| * 1) should do nothing if execute() has not been called. |
| * 2) must do nothing if canCommit == false |
| * 3) once executed, undo should undo commit() first, then execute() |
| * 4) once undone, redo should call commit only if it was called before undo() |
| * @return must conform to same contract as execute() |
| * @throws ExecutionException |
| * |
| */ |
| public final IStatus commit() throws ExecutionException |
| { |
| if (canCommit()) |
| { |
| IStatus result = doCommit(); |
| if (result.getSeverity() == IStatus.OK) |
| { |
| _hasCommitted = true; |
| } |
| else |
| { |
| _hasCommitted = false; |
| _hasCleanState = false; |
| } |
| return result; |
| } |
| throw new ExecutionException("Cannot execute"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * @return the result of the actual commit |
| * @throws ExecutionException |
| */ |
| protected abstract IStatus doCommit() throws ExecutionException; |
| |
| /** |
| * @return true if the operation can be committed |
| */ |
| public boolean canCommit() |
| { |
| return _hasExecuted && !_hasCommitted && _hasCleanState; |
| } |
| |
| public final IStatus execute(IProgressMonitor monitor, IAdaptable info) |
| throws ExecutionException |
| { |
| if (canExecute()) |
| { |
| IStatus result = doExecute(monitor, info); |
| if (result.getSeverity() == IStatus.OK) |
| { |
| _hasExecuted = true; |
| } |
| else |
| { |
| _hasExecuted = false; |
| _hasCleanState = false; |
| } |
| return result; |
| } |
| throw new ExecutionException("Cannot execute"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * @param monitor |
| * @param info |
| * @return the status of the real execution |
| * @throws ExecutionException |
| */ |
| protected abstract IStatus doExecute(IProgressMonitor monitor, IAdaptable info)throws ExecutionException; |
| |
| public final IStatus redo(IProgressMonitor monitor, IAdaptable info) |
| throws ExecutionException { |
| if (canRedo()) |
| { |
| IStatus result = doRedo(monitor, info); |
| if (result.getSeverity() == IStatus.OK) |
| { |
| _hasExecuted = true; |
| } |
| else |
| { |
| _hasExecuted = false; |
| _hasCleanState = false; |
| } |
| return result; |
| } |
| throw new ExecutionException("Cannot redo"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * @param monitor |
| * @param info |
| * @return the status of the real redo |
| * @throws ExecutionException |
| */ |
| protected abstract IStatus doRedo(IProgressMonitor monitor, IAdaptable info) throws ExecutionException; |
| |
| public final IStatus undo(IProgressMonitor monitor, IAdaptable info) |
| throws ExecutionException { |
| if (canUndo()) |
| { |
| IStatus result = doUndo(monitor, info); |
| if (result.getSeverity() == IStatus.OK) |
| { |
| _hasExecuted = false; |
| } |
| else |
| { |
| _hasExecuted = true; |
| _hasCleanState = false; |
| } |
| return result; |
| } |
| throw new ExecutionException("Cannot redo"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * @param monitor |
| * @param info |
| * @return the status of the real redo |
| * @throws ExecutionException |
| */ |
| protected abstract IStatus doUndo(IProgressMonitor monitor, IAdaptable info) throws ExecutionException; |
| |
| public boolean canExecute() { |
| return !_hasExecuted && _hasCleanState; |
| } |
| |
| public boolean canRedo() { |
| return canExecute(); |
| } |
| |
| public boolean canUndo() { |
| return _hasExecuted && _hasCleanState; |
| } |
| |
| /** |
| * @param executed |
| */ |
| protected void setHasExecuted(boolean executed) { |
| _hasExecuted = executed; |
| } |
| |
| /** |
| * @param committed |
| */ |
| protected void setHasCommitted(boolean committed) { |
| _hasCommitted = committed; |
| } |
| |
| /** |
| * @param cleanState |
| */ |
| protected void setHasCleanState(boolean cleanState) { |
| _hasCleanState = cleanState; |
| } |
| |
| /** |
| * @return true if has executed |
| */ |
| protected boolean hasExecuted() { |
| return _hasExecuted; |
| } |
| |
| /** |
| * @return true if has committed |
| */ |
| protected boolean hasCommitted() { |
| return _hasCommitted; |
| } |
| |
| /** |
| * @return true if has clean state |
| */ |
| protected boolean hasCleanState() { |
| return _hasCleanState; |
| } |
| |
| } |