bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/synchronize/CompositeModelProvider.java - platform/eclipse.platform.team - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2017 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.ui.synchronize;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.core.resources.IResource;
 import org.eclipse.team.core.synchronize.ISyncInfoTreeChangeEvent;
 import org.eclipse.team.core.synchronize.SyncInfo;
 import org.eclipse.team.core.synchronize.SyncInfoSet;
 import org.eclipse.team.core.synchronize.SyncInfoTree;
 import org.eclipse.team.ui.synchronize.ISynchronizeModelElement;
 import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;

 /**
  * This class provides functionality for defining composite synchronize model
  * providers. A composite provider is one that breaks up the displayed
  * {@link SyncInfoSet} into subsets that may be displayed using one
  * or more synchronize model providers.
  *
  */
 public abstract class CompositeModelProvider extends AbstractSynchronizeModelProvider {

 	private final List<ISynchronizeModelProvider> providers = new ArrayList<>();
 	private final Map<IResource, List <ISynchronizeModelElement>> resourceToElements = new HashMap<>();
 	private final Map<ISynchronizeModelElement, AbstractSynchronizeModelProvider> elementToProvider = new HashMap<>();

 	protected CompositeModelProvider(ISynchronizePageConfiguration configuration, SyncInfoSet set) {
 		super(configuration, set);
 	}

 	/**
 	 * Add the provider to the list of providers.
 	 * @param provider the provider to be added
 	 */
 	protected void addProvider(ISynchronizeModelProvider provider) {
 		providers.add(provider);
 	}

 	/**
 	 * Remove the provider from the list of providers.
 	 * @param provider the provider to be removed
 	 */
 	protected void removeProvider(ISynchronizeModelProvider provider) {
 		providers.remove(provider);
 		provider.dispose();
 	}

 	@Override
 	protected ISynchronizeModelProvider getProvider(ISynchronizeModelElement element) {
 		return elementToProvider.get(element);
 	}

 	@Override
 	public ISynchronizeModelElement[] getClosestExistingParents(IResource resource) {
 		ISynchronizeModelProvider[] providers = getProviders();
 		if (providers.length == 0) {
 			return new ISynchronizeModelElement[0];
 		}
 		if (providers.length == 1 && providers[0] instanceof AbstractSynchronizeModelProvider) {
 			return ((AbstractSynchronizeModelProvider)providers[0]).getClosestExistingParents(resource);
 		}
 		List<ISynchronizeModelElement> result = new ArrayList<>();
 		for (int i = 0; i < providers.length; i++) {
 			ISynchronizeModelProvider provider = providers[i];
 			if (provider instanceof AbstractSynchronizeModelProvider) {
 				ISynchronizeModelElement[] elements = ((AbstractSynchronizeModelProvider)provider).getClosestExistingParents(resource);
 				for (int j = 0; j < elements.length; j++) {
 					ISynchronizeModelElement element = elements[j];
 					result.add(element);
 				}
 			}
 		}
 		return result.toArray(new ISynchronizeModelElement[result.size()]);
 	}

 	/**
 	 * Return all the sub-providers of this composite.
 	 * @return the sub-providers of this composite
 	 */
 	protected ISynchronizeModelProvider[] getProviders() {
 		return providers.toArray(new ISynchronizeModelProvider[providers.size()]);
 	}

 	/**
 	 * Return the providers that are displaying the given resource.
 	 * @param resource the resource
 	 * @return the providers displaying the resource
 	 */
 	protected ISynchronizeModelProvider[] getProvidersContaining(IResource resource) {
 		List<ISynchronizeModelElement> elements = resourceToElements.get(resource);
 		if (elements == null || elements.isEmpty()) {
 			return new ISynchronizeModelProvider[0];
 		}
 		List<ISynchronizeModelProvider> result = new ArrayList<>();
 		for (Iterator<ISynchronizeModelElement> iter = elements.iterator(); iter.hasNext();) {
 			ISynchronizeModelElement element = iter.next();
 			result.add(getProvider(element));
 		}
 		return result.toArray(new ISynchronizeModelProvider[result.size()]);
 	}

 	@Override
 	protected final void handleResourceAdditions(ISyncInfoTreeChangeEvent event) {
 		handleAdditions(event.getAddedResources());
 	}

 	/**
 	 * Handle the resource additions by adding them to any existing
 	 * sub-providers or by creating addition sub-providers as needed.
 	 * @param resources
 	 */
 	protected void handleAdditions(SyncInfo[] resources) {
 		for (int i = 0; i < resources.length; i++) {
 			SyncInfo info = resources[i];
 			handleAddition(info);
 		}
 	}

 	/**
 	 * Handle the addition of the given sync info to this provider
 	 * @param info the added sync info
 	 */
 	protected abstract void handleAddition(SyncInfo info);

 	@Override
 	protected final void handleResourceChanges(ISyncInfoTreeChangeEvent event) {
 		SyncInfo[] infos = event.getChangedResources();
 		for (int i = 0; i < infos.length; i++) {
 			SyncInfo info = infos[i];
 			handleChange(info);
 		}
 	}

 	/**
 	 * The state of the sync info for a resource has changed. Propagate the
 	 * change to any sub-providers that contain the resource.
 	 * @param info the sync info for the resource whose sync state has changed
 	 */
 	protected void handleChange(SyncInfo info) {
 		handleRemoval(info.getLocal());
 		handleAddition(info);
 	}

 	@Override
 	protected final void handleResourceRemovals(ISyncInfoTreeChangeEvent event) {
 		IResource[] resources = event.getRemovedResources();
 		for (int i = 0; i < resources.length; i++) {
 			IResource resource = resources[i];
 			handleRemoval(resource);
 		}
 	}

 	/**
 	 * Remove the resource from all providers that are displaying it
 	 * @param resource the resource to be removed
 	 */
 	protected void handleRemoval(IResource resource) {
 		ISynchronizeModelProvider[] providers = getProvidersContaining(resource);
 		for (int i = 0; i < providers.length; i++) {
 			ISynchronizeModelProvider provider = providers[i];
 			removeFromProvider(resource, provider);
 		}
 	}

 	/**
 	 * Remove the resource from the sync set of the given provider
 	 * unless the provider is this composite. Subclasses can
 	 * override if they show resources directly.
 	 * @param resource the resource to be removed
 	 * @param provider the provider from which to remove the resource
 	 */
 	protected void removeFromProvider(IResource resource, ISynchronizeModelProvider provider) {
 		if (provider != this) {
 			provider.getSyncInfoSet().remove(resource);
 		}
 	}

 	@Override
 	protected void nodeAdded(ISynchronizeModelElement node, AbstractSynchronizeModelProvider provider) {
 		// Update the resource-to-element map and the element-to-provider map
 		IResource r = node.getResource();
 		if(r != null) {
 			List<ISynchronizeModelElement> elements = resourceToElements.get(r);
 			if(elements == null) {
 				elements = new ArrayList<>(2);
 				resourceToElements.put(r, elements);
 			}
 			elements.add(node);
 		}
 		elementToProvider.put(node, provider);
 		super.nodeAdded(node, provider);
 	}

 	@Override
 	public void modelObjectCleared(ISynchronizeModelElement node) {
 		super.modelObjectCleared(node);
 		IResource r = node.getResource();
 		if(r != null) {
 			List elements = resourceToElements.get(r);
 			if(elements != null) {
 				elements.remove(node);
 				if (elements.isEmpty()) {
 					resourceToElements.remove(r);
 				}
 			}
 		}
 		elementToProvider.remove(node);
 	}

 	@Override
 	protected void recursiveClearModelObjects(ISynchronizeModelElement node) {
 		super.recursiveClearModelObjects(node);
 		if (node == getModelRoot()) {
 			clearProviders();
 		}
 	}

 	private void clearProviders() {
 		for (Iterator iter = providers.iterator(); iter.hasNext();) {
 			ISynchronizeModelProvider provider = (ISynchronizeModelProvider) iter.next();
 			provider.dispose();
 		}
 		providers.clear();
 		resourceToElements.clear();
 		elementToProvider.clear();
 	}

 	/**
 	 * Helper method for creating a provider for the given id.
 	 * @param parent the root node for the new provider
 	 * @param id the id of the providers descriptor
 	 * @return the new provider
 	 */
 	protected ISynchronizeModelProvider createModelProvider(ISynchronizeModelElement parent, String id, SyncInfoTree syncInfoTree) {
 		if (id != null && id.endsWith(FlatModelProvider.FlatModelProviderDescriptor.ID)) {
 			return new FlatModelProvider(this, parent, getConfiguration(), syncInfoTree);
 		} else if (id != null && id.endsWith(CompressedFoldersModelProvider.CompressedFolderModelProviderDescriptor.ID)) {
 			return new CompressedFoldersModelProvider(this, parent, getConfiguration(), syncInfoTree);
 		} else {
 			return new HierarchicalModelProvider(this, parent, getConfiguration(), syncInfoTree);
 		}
 	}

 	@Override
 	public void dispose() {
 		clearProviders();
 		super.dispose();
 	}

 	@Override
 	protected boolean hasViewerState() {
 		return resourceToElements != null && !resourceToElements.isEmpty();
 	}

 	@Override
 	protected ISynchronizeModelElement[] getModelObjects(IResource resource) {
 		List<ISynchronizeModelElement> elements = resourceToElements.get(resource);
 		if (elements == null) {
 			return new ISynchronizeModelElement[0];
 		}
 		return elements.toArray(new ISynchronizeModelElement[elements.size()]);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2017 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.ui.synchronize;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.core.resources.IResource;
	import org.eclipse.team.core.synchronize.ISyncInfoTreeChangeEvent;
	import org.eclipse.team.core.synchronize.SyncInfo;
	import org.eclipse.team.core.synchronize.SyncInfoSet;
	import org.eclipse.team.core.synchronize.SyncInfoTree;
	import org.eclipse.team.ui.synchronize.ISynchronizeModelElement;
	import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;

	/**
	* This class provides functionality for defining composite synchronize model
	* providers. A composite provider is one that breaks up the displayed
	* {@link SyncInfoSet} into subsets that may be displayed using one
	* or more synchronize model providers.
	*
	*/
	public abstract class CompositeModelProvider extends AbstractSynchronizeModelProvider {

	private final List<ISynchronizeModelProvider> providers = new ArrayList<>();
	private final Map<IResource, List <ISynchronizeModelElement>> resourceToElements = new HashMap<>();
	private final Map<ISynchronizeModelElement, AbstractSynchronizeModelProvider> elementToProvider = new HashMap<>();

	protected CompositeModelProvider(ISynchronizePageConfiguration configuration, SyncInfoSet set) {
	super(configuration, set);
	}

	/**
	* Add the provider to the list of providers.
	* @param provider the provider to be added
	*/
	protected void addProvider(ISynchronizeModelProvider provider) {
	providers.add(provider);
	}

	/**
	* Remove the provider from the list of providers.
	* @param provider the provider to be removed
	*/
	protected void removeProvider(ISynchronizeModelProvider provider) {
	providers.remove(provider);
	provider.dispose();
	}

	@Override
	protected ISynchronizeModelProvider getProvider(ISynchronizeModelElement element) {
	return elementToProvider.get(element);
	}

	@Override
	public ISynchronizeModelElement[] getClosestExistingParents(IResource resource) {
	ISynchronizeModelProvider[] providers = getProviders();
	if (providers.length == 0) {
	return new ISynchronizeModelElement[0];
	}
	if (providers.length == 1 && providers[0] instanceof AbstractSynchronizeModelProvider) {
	return ((AbstractSynchronizeModelProvider)providers[0]).getClosestExistingParents(resource);
	}
	List<ISynchronizeModelElement> result = new ArrayList<>();
	for (int i = 0; i < providers.length; i++) {
	ISynchronizeModelProvider provider = providers[i];
	if (provider instanceof AbstractSynchronizeModelProvider) {
	ISynchronizeModelElement[] elements = ((AbstractSynchronizeModelProvider)provider).getClosestExistingParents(resource);
	for (int j = 0; j < elements.length; j++) {
	ISynchronizeModelElement element = elements[j];
	result.add(element);
	}
	}
	}
	return result.toArray(new ISynchronizeModelElement[result.size()]);
	}

	/**
	* Return all the sub-providers of this composite.
	* @return the sub-providers of this composite
	*/
	protected ISynchronizeModelProvider[] getProviders() {
	return providers.toArray(new ISynchronizeModelProvider[providers.size()]);
	}

	/**
	* Return the providers that are displaying the given resource.
	* @param resource the resource
	* @return the providers displaying the resource
	*/
	protected ISynchronizeModelProvider[] getProvidersContaining(IResource resource) {
	List<ISynchronizeModelElement> elements = resourceToElements.get(resource);
	if (elements == null \|\| elements.isEmpty()) {
	return new ISynchronizeModelProvider[0];
	}
	List<ISynchronizeModelProvider> result = new ArrayList<>();
	for (Iterator<ISynchronizeModelElement> iter = elements.iterator(); iter.hasNext();) {
	ISynchronizeModelElement element = iter.next();
	result.add(getProvider(element));
	}
	return result.toArray(new ISynchronizeModelProvider[result.size()]);
	}

	@Override
	protected final void handleResourceAdditions(ISyncInfoTreeChangeEvent event) {
	handleAdditions(event.getAddedResources());
	}

	/**
	* Handle the resource additions by adding them to any existing
	* sub-providers or by creating addition sub-providers as needed.
	* @param resources
	*/
	protected void handleAdditions(SyncInfo[] resources) {
	for (int i = 0; i < resources.length; i++) {
	SyncInfo info = resources[i];
	handleAddition(info);
	}
	}

	/**
	* Handle the addition of the given sync info to this provider
	* @param info the added sync info
	*/
	protected abstract void handleAddition(SyncInfo info);

	@Override
	protected final void handleResourceChanges(ISyncInfoTreeChangeEvent event) {
	SyncInfo[] infos = event.getChangedResources();
	for (int i = 0; i < infos.length; i++) {
	SyncInfo info = infos[i];
	handleChange(info);
	}
	}

	/**
	* The state of the sync info for a resource has changed. Propagate the
	* change to any sub-providers that contain the resource.
	* @param info the sync info for the resource whose sync state has changed
	*/
	protected void handleChange(SyncInfo info) {
	handleRemoval(info.getLocal());
	handleAddition(info);
	}

	@Override
	protected final void handleResourceRemovals(ISyncInfoTreeChangeEvent event) {
	IResource[] resources = event.getRemovedResources();
	for (int i = 0; i < resources.length; i++) {
	IResource resource = resources[i];
	handleRemoval(resource);
	}
	}

	/**
	* Remove the resource from all providers that are displaying it
	* @param resource the resource to be removed
	*/
	protected void handleRemoval(IResource resource) {
	ISynchronizeModelProvider[] providers = getProvidersContaining(resource);
	for (int i = 0; i < providers.length; i++) {
	ISynchronizeModelProvider provider = providers[i];
	removeFromProvider(resource, provider);
	}
	}

	/**
	* Remove the resource from the sync set of the given provider
	* unless the provider is this composite. Subclasses can
	* override if they show resources directly.
	* @param resource the resource to be removed
	* @param provider the provider from which to remove the resource
	*/
	protected void removeFromProvider(IResource resource, ISynchronizeModelProvider provider) {
	if (provider != this) {
	provider.getSyncInfoSet().remove(resource);
	}
	}

	@Override
	protected void nodeAdded(ISynchronizeModelElement node, AbstractSynchronizeModelProvider provider) {
	// Update the resource-to-element map and the element-to-provider map
	IResource r = node.getResource();
	if(r != null) {
	List<ISynchronizeModelElement> elements = resourceToElements.get(r);
	if(elements == null) {
	elements = new ArrayList<>(2);
	resourceToElements.put(r, elements);
	}
	elements.add(node);
	}
	elementToProvider.put(node, provider);
	super.nodeAdded(node, provider);
	}

	@Override
	public void modelObjectCleared(ISynchronizeModelElement node) {
	super.modelObjectCleared(node);
	IResource r = node.getResource();
	if(r != null) {
	List elements = resourceToElements.get(r);
	if(elements != null) {
	elements.remove(node);
	if (elements.isEmpty()) {
	resourceToElements.remove(r);
	}
	}
	}
	elementToProvider.remove(node);
	}

	@Override
	protected void recursiveClearModelObjects(ISynchronizeModelElement node) {
	super.recursiveClearModelObjects(node);
	if (node == getModelRoot()) {
	clearProviders();
	}
	}

	private void clearProviders() {
	for (Iterator iter = providers.iterator(); iter.hasNext();) {
	ISynchronizeModelProvider provider = (ISynchronizeModelProvider) iter.next();
	provider.dispose();
	}
	providers.clear();
	resourceToElements.clear();
	elementToProvider.clear();
	}

	/**
	* Helper method for creating a provider for the given id.
	* @param parent the root node for the new provider
	* @param id the id of the providers descriptor
	* @return the new provider
	*/
	protected ISynchronizeModelProvider createModelProvider(ISynchronizeModelElement parent, String id, SyncInfoTree syncInfoTree) {
	if (id != null && id.endsWith(FlatModelProvider.FlatModelProviderDescriptor.ID)) {
	return new FlatModelProvider(this, parent, getConfiguration(), syncInfoTree);
	} else if (id != null && id.endsWith(CompressedFoldersModelProvider.CompressedFolderModelProviderDescriptor.ID)) {
	return new CompressedFoldersModelProvider(this, parent, getConfiguration(), syncInfoTree);
	} else {
	return new HierarchicalModelProvider(this, parent, getConfiguration(), syncInfoTree);
	}
	}

	@Override
	public void dispose() {
	clearProviders();
	super.dispose();
	}

	@Override
	protected boolean hasViewerState() {
	return resourceToElements != null && !resourceToElements.isEmpty();
	}

	@Override
	protected ISynchronizeModelElement[] getModelObjects(IResource resource) {
	List<ISynchronizeModelElement> elements = resourceToElements.get(resource);
	if (elements == null) {
	return new ISynchronizeModelElement[0];
	}
	return elements.toArray(new ISynchronizeModelElement[elements.size()]);
	}
	}