bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/actions/CVSActionSelectionProperties.java

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

import java.util.*;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.team.internal.ccvs.core.ICVSResource;
import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
import org.eclipse.team.internal.ui.Utils;

/**
 * This class represents a selection for a set of CVS actions.
 */
public class CVSActionSelectionProperties {
	
	// Use a weak hash map so that the properties ae collected when the selection is no longer referenced
	private static Map<IStructuredSelection, CVSActionSelectionProperties> selectionProperties = new WeakHashMap<>();
	
	private Object[] selection;
	private Map<String, Object> properties = new HashMap<>();
	
	private static final String SELECTED_RESOURCES = "selectedResources"; //$NON-NLS-1$
	private static final String NONOVERLAPPING_SELECTED_RESOURCES = "nonoverlappingSelectedResources"; //$NON-NLS-1$
	private static final String CVS_RESOURCE_MAP = "cvsResourceMap"; //$NON-NLS-1$
	
	public static CVSActionSelectionProperties getProperties(IStructuredSelection selection) {
		if (selection == null) return null;
		CVSActionSelectionProperties props = selectionProperties.get(selection);
		if (props == null) {
			props = new CVSActionSelectionProperties(selection);
			selectionProperties.put(selection, props);
		}
		return props;
	}
	
	public CVSActionSelectionProperties(IStructuredSelection selection) {
		// Copy the selection so that the WeakHashMap will not think the seleciton used for the key is still in use
		this.selection = selection.toArray();
	}

	public void put(String key, Object value) {
		properties.put(key, value);
	}
	
	public Object get(String key) {
		return properties.get(key);
	}
	
	public IResource[] getAllSelectedResources() {
		IResource[] resources = (IResource[])get(SELECTED_RESOURCES);
		if (resources == null) {
			resources = getResources(selection);
			put(SELECTED_RESOURCES, resources);
		}
		return resources;
	}

	/*
	 * This method gets the resources from the given objects.
	 * It does so in a manner that is consistent with how the workbench does it.
	 * Tha is, it first uses IContributionResourceAdapter, then IResource,
	 * then ResourceMapping.
	 */
	private IResource[] getResources(Object[] objects) {
		return Utils.getContributedResources(objects);
	}
	
	public IResource[] getNonoverlappingSelectedResources() {
		IResource[] resources = (IResource[])get(NONOVERLAPPING_SELECTED_RESOURCES);
		if (resources == null) {
			resources = getNonOverlapping(getAllSelectedResources());
			put (NONOVERLAPPING_SELECTED_RESOURCES, resources);
		}
		return resources;
	}
		
	public ICVSResource getCVSResourceFor(IResource resource) {
		Map map = (Map)get(CVS_RESOURCE_MAP);
		if (map == null) {
			map = new HashMap();
			put(CVS_RESOURCE_MAP, map);
		}
		ICVSResource cvsResource = (ICVSResource)map.get(resource);
		if (cvsResource == null) {
			cvsResource = CVSWorkspaceRoot.getCVSResourceFor(resource);
			map.put(resource, cvsResource);
		}
		return cvsResource;
	}
	
	/**
	 * Method getNonOverlapping ensures that a resource is not covered more than once.
	 * @param resources
	 * @return IResource[]
	 */
	public static IResource[] getNonOverlapping(IResource[] resources) {
		if (resources == null || resources.length == 0 || resources.length == 1) {
			return resources;
		}
		// Sort the resources so the shortest paths are first
		List<IResource> sorted = new ArrayList<>();
		sorted.addAll(Arrays.asList(resources));
		Collections.sort(sorted, new Comparator<IResource>() {
			@Override
			public int compare(IResource resource0, IResource resource1) {
				return resource0.getFullPath().segmentCount() - resource1.getFullPath().segmentCount();
			}
			@Override
			public boolean equals(Object arg0) {
				return false;
			}
		});
		// Collect all non-overlapping resources
		List<IPath> coveredPaths = new ArrayList<>();
		for (Iterator iter = sorted.iterator(); iter.hasNext();) {
			IResource resource = (IResource) iter.next();
			IPath resourceFullPath = resource.getFullPath();
			boolean covered = false;
			for (Iterator it = coveredPaths.iterator(); it.hasNext();) {
				IPath path = (IPath) it.next();
				if(path.isPrefixOf(resourceFullPath)) {
					covered = true;
				}
			}
			if (covered) {
				// if the resource is covered by a parent, remove it
				iter.remove();
			} else {
				// if the resource is a non-covered folder, add it to the covered paths
				if (resource.getType() == IResource.FOLDER) {
					coveredPaths.add(resource.getFullPath());
				}
			}
		}
		return sorted.toArray(new IResource[sorted.size()]);
	}
	
}