bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/mappings/CheckedInChangeSetCollector.java - platform/eclipse.platform.team - Git at Google

 /*******************************************************************************
  * Copyright (c) 2006 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.mappings;

 import java.util.*;

 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.*;
 import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.team.core.TeamException;
 import org.eclipse.team.core.diff.*;
 import org.eclipse.team.core.diff.provider.DiffTree;
 import org.eclipse.team.core.subscribers.Subscriber;
 import org.eclipse.team.core.synchronize.SyncInfo;
 import org.eclipse.team.core.synchronize.SyncInfoSet;
 import org.eclipse.team.core.variants.IResourceVariant;
 import org.eclipse.team.internal.ccvs.core.*;
 import org.eclipse.team.internal.ccvs.core.mapping.CVSCheckedInChangeSet;
 import org.eclipse.team.internal.ccvs.core.resources.RemoteResource;
 import org.eclipse.team.internal.ccvs.core.syncinfo.ResourceSyncInfo;
 import org.eclipse.team.internal.ccvs.ui.CVSUIPlugin;
 import org.eclipse.team.internal.ccvs.ui.Policy;
 import org.eclipse.team.internal.ccvs.ui.operations.RemoteLogOperation.LogEntryCache;
 import org.eclipse.team.internal.ccvs.ui.subscriber.CVSChangeSetCollector;
 import org.eclipse.team.internal.ccvs.ui.subscriber.LogEntryCacheUpdateHandler;
 import org.eclipse.team.internal.ccvs.ui.subscriber.LogEntryCacheUpdateHandler.ILogsFetchedListener;
 import org.eclipse.team.internal.core.mapping.SyncInfoToDiffConverter;
 import org.eclipse.team.internal.core.subscribers.*;
 import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
 import org.eclipse.team.ui.synchronize.SynchronizePageActionGroup;

 public class CheckedInChangeSetCollector extends BatchingChangeSetManager implements ILogsFetchedListener {

 	/*
 	 * Constant used to store the log entry handler in the configuration so it can
 	 * be kept around over layout changes
 	 */
 	private static final String LOG_ENTRY_HANDLER = CVSUIPlugin.ID + ".LogEntryHandler"; //$NON-NLS-1$

 	/* *****************************************************************************
 	 * Special sync info that has its kind already calculated.
 	 */
 	private class CVSUpdatableSyncInfo extends CVSSyncInfo {
 		public int kind;
 		public CVSUpdatableSyncInfo(int kind, IResource local, IResourceVariant base, IResourceVariant remote, Subscriber s) {
 			super(local, base, remote, s);
 			this.kind = kind;
 		}

 		@Override
 		protected int calculateKind() throws TeamException {
 			return kind;
 		}
 	}

 	IDiffChangeListener diffTreeListener = new IDiffChangeListener() {
 		@Override
 		public void propertyChanged(IDiffTree tree, int property, IPath[] paths) {
 			// Ignore
 		}
 		@Override
 		public void diffsChanged(IDiffChangeEvent event, IProgressMonitor monitor) {
 			if (event.getTree().isEmpty()) {
 				ChangeSet changeSet = getChangeSet(event.getTree());
 				if (changeSet != null) {
 					remove(changeSet);
 				}
 			} else {
 				ChangeSet changeSet = getChangeSet(event.getTree());
 				if (changeSet != null) {
 					fireResourcesChangedEvent(changeSet, getAffectedPaths(event));
 				}
 			}
 		}
 		private IPath[] getAffectedPaths(IDiffChangeEvent event) {
 			Set<IPath> result = new HashSet<>();
 			IPath[] removed = event.getRemovals();
 			for (int i = 0; i < removed.length; i++) {
 				IPath path = removed[i];
 				result.add(path);
 			}
 			IDiff[] diffs = event.getAdditions();
 			for (int j = 0; j < diffs.length; j++) {
 				IDiff diff = diffs[j];
 				result.add(diff.getPath());
 			}
 			diffs = event.getChanges();
 			for (int j = 0; j < diffs.length; j++) {
 				IDiff diff = diffs[j];
 				result.add(diff.getPath());
 			}
 			return result.toArray(new IPath[result.size()]);
 		}
 	};

 	private final ISynchronizePageConfiguration configuration;
 	private boolean disposed;
 	private LogEntryCache logEntryCache;
 	private final Subscriber subscriber;

 	private HashSet<ChangeSet> updatedSets;

 	public CheckedInChangeSetCollector(ISynchronizePageConfiguration configuration, Subscriber subscriber) {
 		this.configuration = configuration;
 		this.subscriber = subscriber;
 	}

 	/**
 	 * Return the configuration for the page that is displaying the model created
 	 * using this collector.
 	 * @return the configuration for the page that is displaying the model created
 	 * using this collector
 	 */
 	public final ISynchronizePageConfiguration getConfiguration() {
 		return configuration;
 	}

 	@Override
 	protected void handleSetAdded(ChangeSet set) {
 		((DiffChangeSet)set).getDiffTree().addDiffChangeListener(diffTreeListener);
 		super.handleSetAdded(set);
 		if (updatedSets != null) {
 			updatedSets.add(set);
 			((DiffTree)((DiffChangeSet)set).getDiffTree()).beginInput();
 		}
 	}

 	@Override
 	protected void handleSetRemoved(ChangeSet set) {
 		((DiffChangeSet)set).getDiffTree().removeDiffChangeListener(diffTreeListener);
 		super.handleSetRemoved(set);
 	}

 	protected ChangeSet getChangeSet(IDiffTree tree) {
 		ChangeSet[] sets = getSets();
 		for (int i = 0; i < sets.length; i++) {
 			ChangeSet changeSet = sets[i];
 			if (((DiffChangeSet)changeSet).getDiffTree() == tree) {
 				return changeSet;
 			}
 		}
 		return null;
 	}

 	public void handleChange(IDiffChangeEvent event) {
 		List<IPath> removals = new ArrayList<>();
 		List<IDiff> additions = new ArrayList<>();
 		removals.addAll(Arrays.asList(event.getRemovals()));
 		additions.addAll(Arrays.asList(event.getAdditions()));
 		IDiff[] changed = event.getChanges();
 		for (int i = 0; i < changed.length; i++) {
 			IDiff diff = changed[i];
 			additions.add(diff);
 			removals.add(diff.getPath());
 		}
 		if (!removals.isEmpty()) {
 			remove(removals.toArray(new IPath[removals.size()]));
 		}
 		if (!additions.isEmpty()) {
 			add(additions.toArray(new IDiff[additions.size()]));
 		}
 	}

 	protected void remove(IPath[] paths) {
 		ChangeSet[] sets = getSets();
 		for (int i = 0; i < sets.length; i++) {
 			DiffChangeSet set = (DiffChangeSet)sets[i];
 			set.remove(paths);
 		}
 	}

 	public synchronized LogEntryCacheUpdateHandler getLogEntryHandler() {
 		LogEntryCacheUpdateHandler handler = (LogEntryCacheUpdateHandler)getConfiguration().getProperty(LOG_ENTRY_HANDLER);
 		if (handler == null) {
 			handler = initializeLogEntryHandler(getConfiguration());
 		}
 		handler.setListener(this);
 		return handler;
 	}

 	/*
 	 * Initialize the log entry handler and place it in the configuration
 	 */
 	private LogEntryCacheUpdateHandler initializeLogEntryHandler(final ISynchronizePageConfiguration configuration) {
 		final LogEntryCacheUpdateHandler logEntryHandler = new LogEntryCacheUpdateHandler(configuration);
 		configuration.setProperty(LOG_ENTRY_HANDLER, logEntryHandler);
 		// Use an action group to get notified when the configuration is disposed
 		configuration.addActionContribution(new SynchronizePageActionGroup() {
 			@Override
 			public void dispose() {
 				super.dispose();
 				LogEntryCacheUpdateHandler handler = (LogEntryCacheUpdateHandler)configuration.getProperty(LOG_ENTRY_HANDLER);
 				if (handler != null) {
 					handler.shutdown();
 					configuration.setProperty(LOG_ENTRY_HANDLER, null);
 				}
 			}
 		});
 		return logEntryHandler;
 	}

 	protected void add(IDiff[] diffs) {
 		LogEntryCacheUpdateHandler handler = getLogEntryHandler();
 		if (handler != null)
 			try {
 				handler.fetch(getSyncInfos(diffs));
 			} catch (CVSException e) {
 				CVSUIPlugin.log(e);
 			}
 	}

 	private SyncInfo[] getSyncInfos(IDiff[] diffs) {
 		SyncInfoSet set = new SyncInfoSet();
 		for (int i = 0; i < diffs.length; i++) {
 			IDiff diff = diffs[i];
 			set.add(getConverter().asSyncInfo(diff, getSubscriber().getResourceComparator()));
 		}
 		return set.getSyncInfos();
 	}

 	public Subscriber getSubscriber() {
 		return subscriber;
 	}

 	@Override
 	public void dispose() {
 		// No longer listen for log entry changes
 		// (The handler is disposed with the page)
 		disposed = true;
 		LogEntryCacheUpdateHandler handler = getLogEntryHandler();
 		if (handler != null) handler.setListener(null);
 		getConfiguration().setProperty(CVSChangeSetCollector.CVS_CHECKED_IN_COLLECTOR, null);
 		logEntryCache = null;
 		super.dispose();
 	}

 	/**
 	 * Fetch the log histories for the remote changes and use this information
 	 * to add each resource to an appropriate commit set.
 	 */
 	private void handleRemoteChanges(final SyncInfo[] infos, final LogEntryCache logEntries, final IProgressMonitor monitor) {
 		try {
 			beginSetUpdate();
 			addLogEntries(infos, logEntries, monitor);
 		} finally {
 			endSetUpdate(monitor);
 		}
 	}

 	private void beginSetUpdate() {
 		updatedSets = new HashSet<>();
 	}

 	private void endSetUpdate(IProgressMonitor monitor) {
 		for (Iterator iter = updatedSets.iterator(); iter.hasNext();) {
 			DiffChangeSet set = (DiffChangeSet) iter.next();
 			try {
 				((DiffTree)set.getDiffTree()).endInput(monitor);
 			} catch (RuntimeException e) {
 				CVSUIPlugin.log(IStatus.ERROR, "Internal error", e); //$NON-NLS-1$
 			}
 		}
 		updatedSets = null;
 	}

 	/*
 	 * Add the following sync info elements to the viewer. It is assumed that these elements have associated
 	 * log entries cached in the log operation.
 	 */
 	private void addLogEntries(SyncInfo[] commentInfos, LogEntryCache logs, IProgressMonitor monitor) {
 		try {
 			monitor.beginTask(null, commentInfos.length * 10);
 			if (logs != null) {
 				for (int i = 0; i < commentInfos.length; i++) {
 					addSyncInfoToCommentNode(commentInfos[i], logs);
 					monitor.worked(10);
 				}
 			}
 		} finally {
 			monitor.done();
 		}
 	}

 	/*
 	 * Create a node for the given sync info object. The logs should contain the log for this info.
 	 *
 	 * @param info the info for which to create a node in the model
 	 * @param log the cvs log for this node
 	 */
 	private void addSyncInfoToCommentNode(SyncInfo info, LogEntryCache logs) {
 		LogEntryCacheUpdateHandler handler = getLogEntryHandler();
 		if (handler != null) {
 			ICVSRemoteResource remoteResource = handler.getRemoteResource(info);
 			if(handler.getSubscriber() instanceof CVSCompareSubscriber && remoteResource != null) {
 				addMultipleRevisions(info, logs, remoteResource);
 			} else {
 				addSingleRevision(info, logs, remoteResource);
 			}
 		}
 	}

 	/*
 	 * Add a single log entry to the model.
 	 *
 	 * @param info
 	 * @param logs
 	 * @param remoteResource
 	 */
 	private void addSingleRevision(SyncInfo info, LogEntryCache logs, ICVSRemoteResource remoteResource) {
 		ILogEntry logEntry = logs.getLogEntry(remoteResource);
 		if (remoteResource != null && !remoteResource.isFolder()) {
 			// For incoming deletions grab the comment for the latest on the same branch
 			// which is now in the attic.
 			try {
 				String remoteRevision = ((ICVSRemoteFile) remoteResource).getRevision();
 				if (isDeletedRemotely(info)) {
 					ILogEntry[] logEntries = logs.getLogEntries(remoteResource);
 					for (int i = 0; i < logEntries.length; i++) {
 						ILogEntry entry = logEntries[i];
 						String revision = entry.getRevision();
 						if (entry.isDeletion() && ResourceSyncInfo.isLaterRevision(revision, remoteRevision)) {
 							logEntry = entry;
 						}
 					}
 				}
 			} catch (TeamException e) {
 				// continue and skip deletion checks
 			}
 		}
 		addRemoteChange(info, remoteResource, logEntry);
 	}

 	/*
 	 * Add multiple log entries to the model.
 	 *
 	 * @param info
 	 * @param logs
 	 * @param remoteResource
 	 */
 	private void addMultipleRevisions(SyncInfo info, LogEntryCache logs, ICVSRemoteResource remoteResource) {
 		ILogEntry[] logEntries = logs.getLogEntries(remoteResource);
 		if(logEntries == null || logEntries.length == 0) {
 			// If for some reason we don't have a log entry, try the latest
 			// remote.
 			addRemoteChange(info, null, null);
 		} else {
 			for (int i = 0; i < logEntries.length; i++) {
 				ILogEntry entry = logEntries[i];
 				addRemoteChange(info, remoteResource, entry);
 			}
 		}
 	}

 	private boolean isDeletedRemotely(SyncInfo info) {
 		int kind = info.getKind();
 		if(kind == (SyncInfo.INCOMING | SyncInfo.DELETION)) return true;
 		if(SyncInfo.getDirection(kind) == SyncInfo.CONFLICTING && info.getRemote() == null) return true;
 		return false;
 	}

 	/*
 	 * Add the remote change to an incoming commit set
 	 */
 	private void addRemoteChange(SyncInfo info, ICVSRemoteResource remoteResource, ILogEntry logEntry) {
 		if (disposed) return;
 		LogEntryCacheUpdateHandler handler = getLogEntryHandler();
 		if(handler != null && remoteResource != null && logEntry != null && handler.isRemoteChange(info)) {
 			if(requiresCustomSyncInfo(info, remoteResource, logEntry)) {
 				info = new CVSUpdatableSyncInfo(info.getKind(), info.getLocal(), info.getBase(), (RemoteResource)logEntry.getRemoteFile(), getSubscriber());
 				try {
 					info.init();
 				} catch (TeamException e) {
 					// this shouldn't happen, we've provided our own calculate kind
 				}
 			}
 			IDiff diff = getConverter().getDeltaFor(info);
 			// Only add the info if the base and remote differ
 			IResourceVariant base = info.getBase();
 			IResourceVariant remote = info.getRemote();
 			if ((base == null && remote != null) || (remote == null && base != null) || (remote != null && base != null && !base.equals(remote))) {
 				synchronized(this) {
 					CVSCheckedInChangeSet set = getChangeSetFor(logEntry);
 					if (set == null) {
 						set = createChangeSetFor(logEntry);
 						add(set);
 					}
 					set.add(diff);
 				}
 			}
 		} else {
 			// The info was not retrieved for the remote change for some reason.
 			// Add the node to the root
 			//addToDefaultSet(DEFAULT_INCOMING_SET_NAME, info);
 		}
 	}

 	private SyncInfoToDiffConverter getConverter() {
 		SyncInfoToDiffConverter converter = Adapters.adapt(subscriber, SyncInfoToDiffConverter.class);
 		if (converter == null)
 			converter = SyncInfoToDiffConverter.getDefault();
 		return converter;
 	}

 	private CVSCheckedInChangeSet createChangeSetFor(ILogEntry logEntry) {
 		return new CVSCheckedInChangeSet(logEntry);
 	}

 	private CVSCheckedInChangeSet getChangeSetFor(ILogEntry logEntry) {
 		ChangeSet[] sets = getSets();
 		for (int i = 0; i < sets.length; i++) {
 			ChangeSet set = sets[i];
 			if (set instanceof CVSCheckedInChangeSet &&
 					set.getComment().equals(logEntry.getComment()) &&
 					((CVSCheckedInChangeSet)set).getAuthor().equals(logEntry.getAuthor())) {
 				return (CVSCheckedInChangeSet)set;
 			}
 		}
 		return null;
 	}

 	private boolean requiresCustomSyncInfo(SyncInfo info, ICVSRemoteResource remoteResource, ILogEntry logEntry) {
 		// Only interested in non-deletions
 		if (logEntry.isDeletion()) return false;
 		// Only require a custom sync info if the remote of the sync info
 		// differs from the remote in the log entry
 		IResourceVariant remote = info.getRemote();
 		if (remote == null) return true;
 		return !remote.equals(remoteResource);
 	}

 	/*
 	 * @see
 	 * org.eclipse.team.ui.synchronize.SyncInfoSetChangeSetCollector#waitUntilDone(
 	 * org.eclipse.core.runtime.IProgressMonitor)
 	 */
 	public void waitUntilDone(IProgressMonitor monitor) {
 		monitor.worked(1);
 		// wait for the event handler to process changes.
 		LogEntryCacheUpdateHandler handler = getLogEntryHandler();
 		if (handler != null) {
 			while(handler.getEventHandlerJob().getState() != Job.NONE) {
 				monitor.worked(1);
 				try {
 					Thread.sleep(10);
 				} catch (InterruptedException e) {
 				}
 				Policy.checkCanceled(monitor);
 			}
 		}
 		monitor.worked(1);
 	}

 	@Override
 	public void logEntriesFetched(SyncInfoSet set, LogEntryCache logEntryCache, IProgressMonitor monitor) {
 		if (disposed) return;
 		// Hold on to the cache so we can use it while commit sets are visible
 		this.logEntryCache = logEntryCache;
 		try {
 			beginInput();
 			handleRemoteChanges(set.getSyncInfos(), logEntryCache, monitor);
 		} finally {
 			endInput(monitor);
 		}
 	}

 	public ICVSRemoteFile getImmediatePredecessor(ICVSRemoteFile file) throws TeamException {
 		if (logEntryCache != null)
 			return logEntryCache.getImmediatePredecessor(file);
 		return null;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2006 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.mappings;

	import java.util.*;

	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.*;
	import org.eclipse.core.runtime.jobs.Job;
	import org.eclipse.team.core.TeamException;
	import org.eclipse.team.core.diff.*;
	import org.eclipse.team.core.diff.provider.DiffTree;
	import org.eclipse.team.core.subscribers.Subscriber;
	import org.eclipse.team.core.synchronize.SyncInfo;
	import org.eclipse.team.core.synchronize.SyncInfoSet;
	import org.eclipse.team.core.variants.IResourceVariant;
	import org.eclipse.team.internal.ccvs.core.*;
	import org.eclipse.team.internal.ccvs.core.mapping.CVSCheckedInChangeSet;
	import org.eclipse.team.internal.ccvs.core.resources.RemoteResource;
	import org.eclipse.team.internal.ccvs.core.syncinfo.ResourceSyncInfo;
	import org.eclipse.team.internal.ccvs.ui.CVSUIPlugin;
	import org.eclipse.team.internal.ccvs.ui.Policy;
	import org.eclipse.team.internal.ccvs.ui.operations.RemoteLogOperation.LogEntryCache;
	import org.eclipse.team.internal.ccvs.ui.subscriber.CVSChangeSetCollector;
	import org.eclipse.team.internal.ccvs.ui.subscriber.LogEntryCacheUpdateHandler;
	import org.eclipse.team.internal.ccvs.ui.subscriber.LogEntryCacheUpdateHandler.ILogsFetchedListener;
	import org.eclipse.team.internal.core.mapping.SyncInfoToDiffConverter;
	import org.eclipse.team.internal.core.subscribers.*;
	import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
	import org.eclipse.team.ui.synchronize.SynchronizePageActionGroup;

	public class CheckedInChangeSetCollector extends BatchingChangeSetManager implements ILogsFetchedListener {

	/*
	* Constant used to store the log entry handler in the configuration so it can
	* be kept around over layout changes
	*/
	private static final String LOG_ENTRY_HANDLER = CVSUIPlugin.ID + ".LogEntryHandler"; //$NON-NLS-1$

	/* *****************************************************************************
	* Special sync info that has its kind already calculated.
	*/
	private class CVSUpdatableSyncInfo extends CVSSyncInfo {
	public int kind;
	public CVSUpdatableSyncInfo(int kind, IResource local, IResourceVariant base, IResourceVariant remote, Subscriber s) {
	super(local, base, remote, s);
	this.kind = kind;
	}

	@Override
	protected int calculateKind() throws TeamException {
	return kind;
	}
	}

	IDiffChangeListener diffTreeListener = new IDiffChangeListener() {
	@Override
	public void propertyChanged(IDiffTree tree, int property, IPath[] paths) {
	// Ignore
	}
	@Override
	public void diffsChanged(IDiffChangeEvent event, IProgressMonitor monitor) {
	if (event.getTree().isEmpty()) {
	ChangeSet changeSet = getChangeSet(event.getTree());
	if (changeSet != null) {
	remove(changeSet);
	}
	} else {
	ChangeSet changeSet = getChangeSet(event.getTree());
	if (changeSet != null) {
	fireResourcesChangedEvent(changeSet, getAffectedPaths(event));
	}
	}
	}
	private IPath[] getAffectedPaths(IDiffChangeEvent event) {
	Set<IPath> result = new HashSet<>();
	IPath[] removed = event.getRemovals();
	for (int i = 0; i < removed.length; i++) {
	IPath path = removed[i];
	result.add(path);
	}
	IDiff[] diffs = event.getAdditions();
	for (int j = 0; j < diffs.length; j++) {
	IDiff diff = diffs[j];
	result.add(diff.getPath());
	}
	diffs = event.getChanges();
	for (int j = 0; j < diffs.length; j++) {
	IDiff diff = diffs[j];
	result.add(diff.getPath());
	}
	return result.toArray(new IPath[result.size()]);
	}
	};

	private final ISynchronizePageConfiguration configuration;
	private boolean disposed;
	private LogEntryCache logEntryCache;
	private final Subscriber subscriber;

	private HashSet<ChangeSet> updatedSets;

	public CheckedInChangeSetCollector(ISynchronizePageConfiguration configuration, Subscriber subscriber) {
	this.configuration = configuration;
	this.subscriber = subscriber;
	}

	/**
	* Return the configuration for the page that is displaying the model created
	* using this collector.
	* @return the configuration for the page that is displaying the model created
	* using this collector
	*/
	public final ISynchronizePageConfiguration getConfiguration() {
	return configuration;
	}

	@Override
	protected void handleSetAdded(ChangeSet set) {
	((DiffChangeSet)set).getDiffTree().addDiffChangeListener(diffTreeListener);
	super.handleSetAdded(set);
	if (updatedSets != null) {
	updatedSets.add(set);
	((DiffTree)((DiffChangeSet)set).getDiffTree()).beginInput();
	}
	}

	@Override
	protected void handleSetRemoved(ChangeSet set) {
	((DiffChangeSet)set).getDiffTree().removeDiffChangeListener(diffTreeListener);
	super.handleSetRemoved(set);
	}

	protected ChangeSet getChangeSet(IDiffTree tree) {
	ChangeSet[] sets = getSets();
	for (int i = 0; i < sets.length; i++) {
	ChangeSet changeSet = sets[i];
	if (((DiffChangeSet)changeSet).getDiffTree() == tree) {
	return changeSet;
	}
	}
	return null;
	}

	public void handleChange(IDiffChangeEvent event) {
	List<IPath> removals = new ArrayList<>();
	List<IDiff> additions = new ArrayList<>();
	removals.addAll(Arrays.asList(event.getRemovals()));
	additions.addAll(Arrays.asList(event.getAdditions()));
	IDiff[] changed = event.getChanges();
	for (int i = 0; i < changed.length; i++) {
	IDiff diff = changed[i];
	additions.add(diff);
	removals.add(diff.getPath());
	}
	if (!removals.isEmpty()) {
	remove(removals.toArray(new IPath[removals.size()]));
	}
	if (!additions.isEmpty()) {
	add(additions.toArray(new IDiff[additions.size()]));
	}
	}

	protected void remove(IPath[] paths) {
	ChangeSet[] sets = getSets();
	for (int i = 0; i < sets.length; i++) {
	DiffChangeSet set = (DiffChangeSet)sets[i];
	set.remove(paths);
	}
	}

	public synchronized LogEntryCacheUpdateHandler getLogEntryHandler() {
	LogEntryCacheUpdateHandler handler = (LogEntryCacheUpdateHandler)getConfiguration().getProperty(LOG_ENTRY_HANDLER);
	if (handler == null) {
	handler = initializeLogEntryHandler(getConfiguration());
	}
	handler.setListener(this);
	return handler;
	}

	/*
	* Initialize the log entry handler and place it in the configuration
	*/
	private LogEntryCacheUpdateHandler initializeLogEntryHandler(final ISynchronizePageConfiguration configuration) {
	final LogEntryCacheUpdateHandler logEntryHandler = new LogEntryCacheUpdateHandler(configuration);
	configuration.setProperty(LOG_ENTRY_HANDLER, logEntryHandler);
	// Use an action group to get notified when the configuration is disposed
	configuration.addActionContribution(new SynchronizePageActionGroup() {
	@Override
	public void dispose() {
	super.dispose();
	LogEntryCacheUpdateHandler handler = (LogEntryCacheUpdateHandler)configuration.getProperty(LOG_ENTRY_HANDLER);
	if (handler != null) {
	handler.shutdown();
	configuration.setProperty(LOG_ENTRY_HANDLER, null);
	}
	}
	});
	return logEntryHandler;
	}

	protected void add(IDiff[] diffs) {
	LogEntryCacheUpdateHandler handler = getLogEntryHandler();
	if (handler != null)
	try {
	handler.fetch(getSyncInfos(diffs));
	} catch (CVSException e) {
	CVSUIPlugin.log(e);
	}
	}

	private SyncInfo[] getSyncInfos(IDiff[] diffs) {
	SyncInfoSet set = new SyncInfoSet();
	for (int i = 0; i < diffs.length; i++) {
	IDiff diff = diffs[i];
	set.add(getConverter().asSyncInfo(diff, getSubscriber().getResourceComparator()));
	}
	return set.getSyncInfos();
	}

	public Subscriber getSubscriber() {
	return subscriber;
	}

	@Override
	public void dispose() {
	// No longer listen for log entry changes
	// (The handler is disposed with the page)
	disposed = true;
	LogEntryCacheUpdateHandler handler = getLogEntryHandler();
	if (handler != null) handler.setListener(null);
	getConfiguration().setProperty(CVSChangeSetCollector.CVS_CHECKED_IN_COLLECTOR, null);
	logEntryCache = null;
	super.dispose();
	}

	/**
	* Fetch the log histories for the remote changes and use this information
	* to add each resource to an appropriate commit set.
	*/
	private void handleRemoteChanges(final SyncInfo[] infos, final LogEntryCache logEntries, final IProgressMonitor monitor) {
	try {
	beginSetUpdate();
	addLogEntries(infos, logEntries, monitor);
	} finally {
	endSetUpdate(monitor);
	}
	}

	private void beginSetUpdate() {
	updatedSets = new HashSet<>();
	}

	private void endSetUpdate(IProgressMonitor monitor) {
	for (Iterator iter = updatedSets.iterator(); iter.hasNext();) {
	DiffChangeSet set = (DiffChangeSet) iter.next();
	try {
	((DiffTree)set.getDiffTree()).endInput(monitor);
	} catch (RuntimeException e) {
	CVSUIPlugin.log(IStatus.ERROR, "Internal error", e); //$NON-NLS-1$
	}
	}
	updatedSets = null;
	}

	/*
	* Add the following sync info elements to the viewer. It is assumed that these elements have associated
	* log entries cached in the log operation.
	*/
	private void addLogEntries(SyncInfo[] commentInfos, LogEntryCache logs, IProgressMonitor monitor) {
	try {
	monitor.beginTask(null, commentInfos.length * 10);
	if (logs != null) {
	for (int i = 0; i < commentInfos.length; i++) {
	addSyncInfoToCommentNode(commentInfos[i], logs);
	monitor.worked(10);
	}
	}
	} finally {
	monitor.done();
	}
	}

	/*
	* Create a node for the given sync info object. The logs should contain the log for this info.
	*
	* @param info the info for which to create a node in the model
	* @param log the cvs log for this node
	*/
	private void addSyncInfoToCommentNode(SyncInfo info, LogEntryCache logs) {
	LogEntryCacheUpdateHandler handler = getLogEntryHandler();
	if (handler != null) {
	ICVSRemoteResource remoteResource = handler.getRemoteResource(info);
	if(handler.getSubscriber() instanceof CVSCompareSubscriber && remoteResource != null) {
	addMultipleRevisions(info, logs, remoteResource);
	} else {
	addSingleRevision(info, logs, remoteResource);
	}
	}
	}

	/*
	* Add a single log entry to the model.
	*
	* @param info
	* @param logs
	* @param remoteResource
	*/
	private void addSingleRevision(SyncInfo info, LogEntryCache logs, ICVSRemoteResource remoteResource) {
	ILogEntry logEntry = logs.getLogEntry(remoteResource);
	if (remoteResource != null && !remoteResource.isFolder()) {
	// For incoming deletions grab the comment for the latest on the same branch
	// which is now in the attic.
	try {
	String remoteRevision = ((ICVSRemoteFile) remoteResource).getRevision();
	if (isDeletedRemotely(info)) {
	ILogEntry[] logEntries = logs.getLogEntries(remoteResource);
	for (int i = 0; i < logEntries.length; i++) {
	ILogEntry entry = logEntries[i];
	String revision = entry.getRevision();
	if (entry.isDeletion() && ResourceSyncInfo.isLaterRevision(revision, remoteRevision)) {
	logEntry = entry;
	}
	}
	}
	} catch (TeamException e) {
	// continue and skip deletion checks
	}
	}
	addRemoteChange(info, remoteResource, logEntry);
	}

	/*
	* Add multiple log entries to the model.
	*
	* @param info
	* @param logs
	* @param remoteResource
	*/
	private void addMultipleRevisions(SyncInfo info, LogEntryCache logs, ICVSRemoteResource remoteResource) {
	ILogEntry[] logEntries = logs.getLogEntries(remoteResource);
	if(logEntries == null \|\| logEntries.length == 0) {
	// If for some reason we don't have a log entry, try the latest
	// remote.
	addRemoteChange(info, null, null);
	} else {
	for (int i = 0; i < logEntries.length; i++) {
	ILogEntry entry = logEntries[i];
	addRemoteChange(info, remoteResource, entry);
	}
	}
	}

	private boolean isDeletedRemotely(SyncInfo info) {
	int kind = info.getKind();
	if(kind == (SyncInfo.INCOMING \| SyncInfo.DELETION)) return true;
	if(SyncInfo.getDirection(kind) == SyncInfo.CONFLICTING && info.getRemote() == null) return true;
	return false;
	}

	/*
	* Add the remote change to an incoming commit set
	*/
	private void addRemoteChange(SyncInfo info, ICVSRemoteResource remoteResource, ILogEntry logEntry) {
	if (disposed) return;
	LogEntryCacheUpdateHandler handler = getLogEntryHandler();
	if(handler != null && remoteResource != null && logEntry != null && handler.isRemoteChange(info)) {
	if(requiresCustomSyncInfo(info, remoteResource, logEntry)) {
	info = new CVSUpdatableSyncInfo(info.getKind(), info.getLocal(), info.getBase(), (RemoteResource)logEntry.getRemoteFile(), getSubscriber());
	try {
	info.init();
	} catch (TeamException e) {
	// this shouldn't happen, we've provided our own calculate kind
	}
	}
	IDiff diff = getConverter().getDeltaFor(info);
	// Only add the info if the base and remote differ
	IResourceVariant base = info.getBase();
	IResourceVariant remote = info.getRemote();
	if ((base == null && remote != null) \|\| (remote == null && base != null) \|\| (remote != null && base != null && !base.equals(remote))) {
	synchronized(this) {
	CVSCheckedInChangeSet set = getChangeSetFor(logEntry);
	if (set == null) {
	set = createChangeSetFor(logEntry);
	add(set);
	}
	set.add(diff);
	}
	}
	} else {
	// The info was not retrieved for the remote change for some reason.
	// Add the node to the root
	//addToDefaultSet(DEFAULT_INCOMING_SET_NAME, info);
	}
	}

	private SyncInfoToDiffConverter getConverter() {
	SyncInfoToDiffConverter converter = Adapters.adapt(subscriber, SyncInfoToDiffConverter.class);
	if (converter == null)
	converter = SyncInfoToDiffConverter.getDefault();
	return converter;
	}

	private CVSCheckedInChangeSet createChangeSetFor(ILogEntry logEntry) {
	return new CVSCheckedInChangeSet(logEntry);
	}

	private CVSCheckedInChangeSet getChangeSetFor(ILogEntry logEntry) {
	ChangeSet[] sets = getSets();
	for (int i = 0; i < sets.length; i++) {
	ChangeSet set = sets[i];
	if (set instanceof CVSCheckedInChangeSet &&
	set.getComment().equals(logEntry.getComment()) &&
	((CVSCheckedInChangeSet)set).getAuthor().equals(logEntry.getAuthor())) {
	return (CVSCheckedInChangeSet)set;
	}
	}
	return null;
	}

	private boolean requiresCustomSyncInfo(SyncInfo info, ICVSRemoteResource remoteResource, ILogEntry logEntry) {
	// Only interested in non-deletions
	if (logEntry.isDeletion()) return false;
	// Only require a custom sync info if the remote of the sync info
	// differs from the remote in the log entry
	IResourceVariant remote = info.getRemote();
	if (remote == null) return true;
	return !remote.equals(remoteResource);
	}

	/*
	* @see
	* org.eclipse.team.ui.synchronize.SyncInfoSetChangeSetCollector#waitUntilDone(
	* org.eclipse.core.runtime.IProgressMonitor)
	*/
	public void waitUntilDone(IProgressMonitor monitor) {
	monitor.worked(1);
	// wait for the event handler to process changes.
	LogEntryCacheUpdateHandler handler = getLogEntryHandler();
	if (handler != null) {
	while(handler.getEventHandlerJob().getState() != Job.NONE) {
	monitor.worked(1);
	try {
	Thread.sleep(10);
	} catch (InterruptedException e) {
	}
	Policy.checkCanceled(monitor);
	}
	}
	monitor.worked(1);
	}

	@Override
	public void logEntriesFetched(SyncInfoSet set, LogEntryCache logEntryCache, IProgressMonitor monitor) {
	if (disposed) return;
	// Hold on to the cache so we can use it while commit sets are visible
	this.logEntryCache = logEntryCache;
	try {
	beginInput();
	handleRemoteChanges(set.getSyncInfos(), logEntryCache, monitor);
	} finally {
	endInput(monitor);
	}
	}

	public ICVSRemoteFile getImmediatePredecessor(ICVSRemoteFile file) throws TeamException {
	if (logEntryCache != null)
	return logEntryCache.getImmediatePredecessor(file);
	return null;
	}
	}