import org.eclipse.core.resources.mapping.ResourceMapping;

import org.eclipse.core.resources.mapping.ResourceMappingContext;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.jobs.ISchedulingRule;

import org.eclipse.core.runtime.jobs.MultiRule;

import org.eclipse.team.internal.ccvs.core.resources.EclipseSynchronizer;

import org.eclipse.team.internal.ui.Utils;

	/**

	 * Run the operation for the sync infos from the given project. By default, a lock

	 * is acquired on the project.

	 * @param projectSyncInfos the project syncInfos

	 * @param project the project

	 * @param monitor a progress monitor

	 * @throws InvocationTargetException

	 */

	protected void run(final Map projectSyncInfos, final IProject project,

			IProgressMonitor monitor) throws InvocationTargetException {

		try {

			IResource[] resources = getIResourcesFrom(((SyncInfoSet) projectSyncInfos

					.get(project)).getSyncInfos());

			ResourceMapping[] selectedMappings = Utils

					.getResourceMappings(resources);

			ResourceMappingContext context = new SingleProjectSubscriberContext(

					CVSProviderPlugin.getPlugin().getCVSWorkspaceSubscriber(),

					false, project);

			SynchronizationScopeManager manager = new SingleProjectScopeManager(

					getJobName(), selectedMappings, context, true, project);

			manager.initialize(null);

			ISchedulingRule updateRule = getUpdateRule(manager);

			// Pass the scheduling rule to the synchronizer so that sync change

			// events

			// and cache commits to disk are batched

			EclipseSynchronizer.getInstance().run(updateRule,

					new ICVSRunnable() {

						public void run(IProgressMonitor monitor)

								throws CVSException {

							try {

								runWithProjectRule(project,

										(SyncInfoSet) projectSyncInfos

												.get(project), monitor);

							} catch (TeamException e) {

								throw CVSException.wrapException(e);

							}

						}

					}, Policy.subMonitorFor(monitor, 100));

		} catch (TeamException e) {

			throw new InvocationTargetException(e);

		} catch (CoreException e) {

			throw new InvocationTargetException(e);

		}

	}

	private ISchedulingRule getUpdateRule(SynchronizationScopeManager manager) {

		ISchedulingRule rule = null;

		ResourceMapping[] mappings = manager.getScope().getMappings();

		for (int i = 0; i < mappings.length; i++) {

			ResourceMapping mapping = mappings[i];

			IProject[] mappingProjects = mapping.getProjects();

			for (int j = 0; j < mappingProjects.length; j++) {

				if (rule == null) {

					rule = mappingProjects[j];

				} else {

					rule = MultiRule.combine(rule, mappingProjects[j]);

				}

			}

		}

		return rule;

	}