/*******************************************************************************
* Copyright (c) 2000, 2011 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.team.internal.ccvs.ui.actions;
import java.lang.reflect.InvocationTargetException;
import java.util.HashSet;
import java.util.Set;
import org.eclipse.core.resources.*;
import org.eclipse.core.resources.mapping.*;
import org.eclipse.core.runtime.*;
import org.eclipse.team.core.RepositoryProvider;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.core.mapping.ISynchronizationScopeManager;
import org.eclipse.team.core.mapping.provider.SynchronizationScopeManager;
import org.eclipse.team.core.subscribers.Subscriber;
import org.eclipse.team.core.subscribers.SubscriberResourceMappingContext;
import org.eclipse.team.internal.ccvs.core.CVSProviderPlugin;
import org.eclipse.team.internal.ccvs.ui.CVSUIMessages;
import org.eclipse.team.internal.ccvs.ui.Policy;
import org.eclipse.team.internal.ccvs.ui.operations.RepositoryProviderOperation;
import org.eclipse.team.internal.ui.Utils;
import org.eclipse.team.internal.ui.mapping.BuildScopeOperation;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;
/**
* A specialized workspace actions that operates on resource traversals
* instead of resources/
*/
public abstract class WorkspaceTraversalAction extends WorkspaceAction {
/**
* Return the selected mappings that contain resources
* within a CVS managed project.
* @return the selected mappings that contain resources
* within a CVS managed project
*/
protected ResourceMapping[] getCVSResourceMappings() {
return getSelectedResourceMappings(CVSProviderPlugin.getTypeId());
}
private static ResourceTraversal[] getTraversals(IWorkbenchPart part, ISynchronizationScopeManager manager, IProgressMonitor monitor) throws CoreException {
try {
BuildScopeOperation op = new BuildScopeOperation(part, manager);
op.run(monitor);
return manager.getScope().getTraversals();
} catch (InvocationTargetException e) {
throw TeamException.asTeamException(e);
} catch (InterruptedException e) {
throw new OperationCanceledException();
}
}
private static IResource[] getRootTraversalResources(ISynchronizationScopeManager manager, IProgressMonitor monitor) throws CoreException {
Set<IResource> result = new HashSet<>();
ResourceTraversal[] traversals = getTraversals(null, manager, monitor);
for (int i = 0; i < traversals.length; i++) {
ResourceTraversal traversal = traversals[i];
IResource[] resources = traversal.getResources();
for (int k = 0; k < resources.length; k++) {
IResource resource = resources[k];
if (RepositoryProvider.getProvider(resource.getProject(), CVSProviderPlugin.getTypeId()) != null) {
result.add(resource);
}
}
}
return result.toArray(new IResource[result.size()]);
}
protected Subscriber getWorkspaceSubscriber() {
return CVSProviderPlugin.getPlugin().getCVSWorkspaceSubscriber();
}
public static IResource[] getResourcesToCompare(ResourceMapping[] mappings, Subscriber subscriber) throws InvocationTargetException {
ISynchronizationScopeManager manager = new SynchronizationScopeManager("", //$NON-NLS-1$
mappings, SubscriberResourceMappingContext.createContext(subscriber), true);
try {
return getResourcesToCompare(manager);
} finally {
manager.dispose();
}
}
protected IResource[] getResourcesToCompare(final Subscriber subscriber) throws InvocationTargetException {
return getResourcesToCompare(getCVSResourceMappings(), subscriber);
}
protected ResourceMappingContext getResourceMappingContext() {
return SubscriberResourceMappingContext.createContext(CVSProviderPlugin.getPlugin().getCVSWorkspaceSubscriber());
}
public static IResource[] getResourcesToCompare(final ISynchronizationScopeManager manager) throws InvocationTargetException {
// Determine what resources need to be synchronized.
// Use a resource mapping context to include any relevant remote resources
final IResource[][] resources = new IResource[][] { null };
try {
PlatformUI.getWorkbench().getProgressService().busyCursorWhile(monitor -> {
try {
resources[0] = getRootTraversalResources(manager, monitor);
} catch (CoreException e) {
throw new InvocationTargetException(e);
}
});
} catch (InterruptedException e) {
// Canceled
return null;
}
return resources[0];
}
public static IResource[] getProjects(IResource[] resources) {
Set<IProject> projects = new HashSet<>();
for (int i = 0; i < resources.length; i++) {
IResource resource = resources[i];
projects.add(resource.getProject());
}
return projects.toArray(new IResource[projects.size()]);
}
/**
*
* @param mappings
* @return
*
* @deprecated need to find a better way to do this
*/
@Deprecated
public static boolean isLogicalModel(ResourceMapping[] mappings) {
for (int i = 0; i < mappings.length; i++) {
ResourceMapping mapping = mappings[i];
if (! (mapping.getModelObject() instanceof IResource) ) {
return true;
}
}
return false;
}
protected IFile getSelectedFile() {
ResourceMapping[] mappings = getCVSResourceMappings();
if (mappings.length == 1) {
IResource resource = Utils.getResource(mappings[0].getModelObject());
if (resource != null && resource.getType() == IResource.FILE)
return (IFile)resource;
}
return null;
}
protected boolean hasOutgoingChanges(final RepositoryProviderOperation operation) throws InvocationTargetException, InterruptedException {
final boolean[] hasChange = new boolean[] { false };
PlatformUI.getWorkbench().getProgressService().run(true, true, monitor -> {
try {
monitor.beginTask(CVSUIMessages.WorkspaceTraversalAction_0, 100);
operation.buildScope(Policy.subMonitorFor(monitor, 50));
hasChange[0] = CVSProviderPlugin.getPlugin().getCVSWorkspaceSubscriber()
.hasLocalChanges(operation.getScope().getTraversals(), Policy.subMonitorFor(monitor, 50));
} catch (CoreException e) {
throw new InvocationTargetException(e);
} finally {
monitor.done();
}
});
return hasChange[0];
}
/**
* Return the complete set of traversals to be targeted by the action
* including those that are included by consulting the models.
*
* @param monitor
* a progress monitor
* @return the complete set of traversals to be targeted by the action
* @throws CoreException
*/
protected ResourceTraversal[] getTraversals(IProgressMonitor monitor) throws CoreException {
SynchronizationScopeManager scopeManager = getScopeManager();
try {
return getTraversals(getTargetPart(), scopeManager, monitor);
} finally {
scopeManager.dispose();
}
}
/**
* Return a scope manager that provides the scope for the action.
* @return a scope manager that provides the scope for the action
*/
protected SynchronizationScopeManager getScopeManager() {
return new SynchronizationScopeManager(
"", //$NON-NLS-1$
getCVSResourceMappings(),
getResourceMappingContext(), true);
}
}
