Attachment #289030 for bug #217489

Lines 17-26 Link Here

(-)designer/bundles/patch/eclipse/org.eclipse.core.resources/src/org/eclipse/core/internal/events/ResourceDelta.java (-60 / +87 lines)
17		17
18	import java.util.Map;	18	import java.util.Map;
19	import java.util.Map.Entry;	19	import java.util.Map.Entry;
20	import org.eclipse.core.internal.resources.*;	20
		21	import org.eclipse.core.internal.resources.ICoreConstants;
		22	import org.eclipse.core.internal.resources.IMarkerSetElement;
		23	import org.eclipse.core.internal.resources.MarkerSet;
		24	import org.eclipse.core.internal.resources.ResourceInfo;
21	import org.eclipse.core.internal.watson.ElementTree;	25	import org.eclipse.core.internal.watson.ElementTree;
22	import org.eclipse.core.resources.*;	26	import org.eclipse.core.resources.IContainer;
23	import org.eclipse.core.runtime.*;	27	import org.eclipse.core.resources.IMarkerDelta;
		28	import org.eclipse.core.resources.IResource;
		29	import org.eclipse.core.resources.IResourceDelta;
		30	import org.eclipse.core.resources.IResourceDeltaVisitor;
		31	import org.eclipse.core.runtime.Assert;
		32	import org.eclipse.core.runtime.CoreException;
		33	import org.eclipse.core.runtime.IPath;
		34	import org.eclipse.core.runtime.Path;
		35	import org.eclipse.core.runtime.PlatformObject;
24		36
25	/**	37	/**
26	* Concrete implementation of the IResourceDelta interface. Each ResourceDelta	38	* Concrete implementation of the IResourceDelta interface. Each ResourceDelta
Lines 131-165 Link Here
131	if (!path.isRoot() && !nodeIDMap.isEmpty()) {	143	if (!path.isRoot() && !nodeIDMap.isEmpty()) {
132	int kind = getKind();	144	int kind = getKind();
133	switch (kind) {	145	switch (kind) {
134	case CHANGED :	146	case CHANGED :
135	case ADDED :	147	case ADDED :
136	IPath oldPath = nodeIDMap.getOldPath(newInfo.getNodeId());	148	IPath oldPath = nodeIDMap.getOldPath(newInfo.getNodeId());
137	if (oldPath != null && !oldPath.equals(path)) {	149	if (oldPath != null && !oldPath.equals(path)) {
138	//get the old info from the old tree	150	//get the old info from the old tree
139	ResourceInfo actualOldInfo = (ResourceInfo) oldTree.getElementData(oldPath);	151	ResourceInfo actualOldInfo = (ResourceInfo) oldTree.getElementData(oldPath);
140	// Replace change flags by comparing old info with new info,	152	// Replace change flags by comparing old info with new info,
141	// Note that we want to retain the kind flag, but replace all other flags	153	// Note that we want to retain the kind flag, but replace all other flags
142	// This is done only for MOVED_FROM, not MOVED_TO, since a resource may be both.	154	// This is done only for MOVED_FROM, not MOVED_TO, since a resource may be both.
143	status = (status & KIND_MASK) \| (deltaInfo.getComparator().compare(actualOldInfo, newInfo) & ~KIND_MASK);	155	status = (status & KIND_MASK) \| (deltaInfo.getComparator().compare(actualOldInfo, newInfo) & ~KIND_MASK);
144	status \|= MOVED_FROM;	156	status \|= MOVED_FROM;
145	//our API states that MOVED_FROM must be in conjunction with ADDED \| (CHANGED + REPLACED)	157	//our API states that MOVED_FROM must be in conjunction with ADDED \| (CHANGED + REPLACED)
146	if (kind == CHANGED)	158	if (kind == CHANGED)
147	status = status \| REPLACED \| CONTENT;	159	status = status \| REPLACED \| CONTENT;
148	//check for gender change	160	//check for gender change
149	if (oldInfo != null && newInfo != null && oldInfo.getType() != newInfo.getType())	161	if (oldInfo != null && newInfo != null && oldInfo.getType() != newInfo.getType())
150	status \|= TYPE;	162	status \|= TYPE;
151	}	163	} else if (kind == ADDED && oldInfo != null) {
		164	// We only have an oldInfo if not a move then for a copy
		165	status \|= COPIED_FROM;
		166	}
152	}	167	}
153	switch (kind) {	168	switch (kind) {
154	case REMOVED :	169	case REMOVED :
155	case CHANGED :	170	case CHANGED :
156	IPath newPath = nodeIDMap.getNewPath(oldInfo.getNodeId());	171	IPath newPath = nodeIDMap.getNewPath(oldInfo.getNodeId());
157	if (newPath != null && !newPath.equals(path)) {	172	if (newPath != null && !newPath.equals(path)) {
158	status \|= MOVED_TO;	173	status \|= MOVED_TO;
159	//our API states that MOVED_TO must be in conjunction with REMOVED \| (CHANGED + REPLACED)	174	//our API states that MOVED_TO must be in conjunction with REMOVED \| (CHANGED + REPLACED)
160	if (kind == CHANGED)	175	if (kind == CHANGED)
161	status = status \| REPLACED \| CONTENT;	176	status = status \| REPLACED \| CONTENT;
162	}	177	}
163	}	178	}
164	}	179	}
165		180
Lines 272-277 Link Here
272	if ((status & MOVED_FROM) != 0) {	287	if ((status & MOVED_FROM) != 0) {
273	return deltaInfo.getNodeIDMap().getOldPath(newInfo.getNodeId());	288	return deltaInfo.getNodeIDMap().getOldPath(newInfo.getNodeId());
274	}	289	}
		290	if ((status & (COPIED_FROM)) != 0) {
		291	// We can do this because the this implementation is only good within
		292	// the listener
		293	IResource oldRes = (IResource) deltaInfo.getWorkspace().getCopyMapRead().get(Long.valueOf(newInfo.getNodeId()));
		294	return oldRes.getFullPath();
		295	}
275	return null;	296	return null;
276	}	297	}
277		298
Lines 411-437 Link Here
411	buffer.append(getFullPath());	432	buffer.append(getFullPath());
412	buffer.append('[');	433	buffer.append('[');
413	switch (getKind()) {	434	switch (getKind()) {
414	case ADDED :	435	case ADDED :
415	buffer.append('+');	436	buffer.append('+');
416	break;	437	break;
417	case ADDED_PHANTOM :	438	case ADDED_PHANTOM :
418	buffer.append('>');	439	buffer.append('>');
419	break;	440	break;
420	case REMOVED :	441	case REMOVED :
421	buffer.append('-');	442	buffer.append('-');
422	break;	443	break;
423	case REMOVED_PHANTOM :	444	case REMOVED_PHANTOM :
424	buffer.append('<');	445	buffer.append('<');
425	break;	446	break;
426	case CHANGED :	447	case CHANGED :
427	buffer.append('*');	448	buffer.append('*');
428	break;	449	break;
429	case NO_CHANGE :	450	case NO_CHANGE :
430	buffer.append('~');	451	buffer.append('~');
431	break;	452	break;
432	default :	453	default :
433	buffer.append('?');	454	buffer.append('?');
434	break;	455	break;
435	}	456	}
436	buffer.append("]: {"); //$NON-NLS-1$	457	buffer.append("]: {"); //$NON-NLS-1$
437	int changeFlags = getFlags();	458	int changeFlags = getFlags();
Lines 442-447 Link Here
442	buffer.append("CONTENT"); //$NON-NLS-1$	463	buffer.append("CONTENT"); //$NON-NLS-1$
443	prev = true;	464	prev = true;
444	}	465	}
		466	if ((changeFlags & COPIED_FROM) != 0) {
		467	if (prev)
		468	buffer.append(" \| "); //$NON-NLS-1$
		469	buffer.append("COPIED_FROM(" + getMovedFromPath() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
		470	prev = true;
		471	}
445	if ((changeFlags & LOCAL_CHANGED) != 0) {	472	if ((changeFlags & LOCAL_CHANGED) != 0) {
446	if (prev)	473	if (prev)
447	buffer.append(" \| "); //$NON-NLS-1$	474	buffer.append(" \| "); //$NON-NLS-1$
Lines 532-546 Link Here
532	if (addComma)	559	if (addComma)
533	buffer.append(',');	560	buffer.append(',');
534	switch (delta.getKind()) {	561	switch (delta.getKind()) {
535	case IResourceDelta.ADDED :	562	case IResourceDelta.ADDED :
536	buffer.append('+');	563	buffer.append('+');
537	break;	564	break;
538	case IResourceDelta.REMOVED :	565	case IResourceDelta.REMOVED :
539	buffer.append('-');	566	buffer.append('-');
540	break;	567	break;
541	case IResourceDelta.CHANGED :	568	case IResourceDelta.CHANGED :
542	buffer.append('*');	569	buffer.append('*');
543	break;	570	break;
544	}	571	}
545	buffer.append(delta.getId());	572	buffer.append(delta.getId());
546	addComma = true;	573	addComma = true;




package org.eclipse.core.internal.events;

import java.util.Map;

import org.eclipse.core.internal.dtree.DeltaDataTree;
import org.eclipse.core.internal.dtree.NodeComparison;
import org.eclipse.core.internal.resources.ICoreConstants;
import org.eclipse.core.internal.resources.MarkerSet;
import org.eclipse.core.internal.resources.Project;
import org.eclipse.core.internal.resources.Resource;
import org.eclipse.core.internal.resources.ResourceInfo;
import org.eclipse.core.internal.resources.Workspace;
import org.eclipse.core.internal.watson.ElementTree;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResourceDelta;

			ResourceDelta child = (ResourceDelta) element;
			IPath path = child.getFullPath();
			switch (child.getKind()) {
			case IResourceDelta.ADDED :
				nodeIDMap.putNewPath(child.newInfo.getNodeId(), path);
				break;
			case IResourceDelta.REMOVED :
				nodeIDMap.putOldPath(child.oldInfo.getNodeId(), path);
				break;
			case IResourceDelta.CHANGED :
				long oldID = child.oldInfo.getNodeId();
				long newID = child.newInfo.getNodeId();
				//don't add entries to the map if nothing has changed.
				if (oldID != newID) {
					nodeIDMap.putOldPath(oldID, path);
					nodeIDMap.putNewPath(newID, path);
				}
				break;
			}
			//recurse
			computeNodeIDMap(child, nodeIDMap);

			result.setOldInfo((ResourceInfo) compare.getOldData());
			result.setNewInfo((ResourceInfo) compare.getNewData());
		}
		// fix bug 217489
		// See if this is a copy and get the info
		if (comparison == IResourceDelta.ADDED && workspace.getCopyMapRead() != null) {
			Resource sourceRes = (Resource) workspace.getCopyMapRead().get(Long.valueOf(result.newInfo.getNodeId()));
			if (sourceRes != null)
				result.setOldInfo(sourceRes.getResourceInfo(false, false));
		}

		// recurse over the children
		IPath[] childKeys = delta.getChildren(pathInDelta);
		int numChildren = childKeys.length;




 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Serge Beauchamp (Freescale Semiconductor) - [252996] add resource filtering
 *******************************************************************************/
package org.eclipse.core.internal.localstore;

import java.net.URI;
import java.util.LinkedList;

import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.internal.resources.Container;
import org.eclipse.core.internal.resources.File;
import org.eclipse.core.internal.resources.FilterDescription;
import org.eclipse.core.internal.resources.Folder;
import org.eclipse.core.internal.resources.Project;
import org.eclipse.core.internal.resources.Resource;
import org.eclipse.core.internal.resources.ResourceInfo;
import org.eclipse.core.internal.resources.ResourceStatus;
import org.eclipse.core.internal.resources.Workspace;
import org.eclipse.core.internal.utils.Messages;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.osgi.util.NLS;

//

		Resource destination = getDestinationResource(source, sufix);
		if (!copyProperties(source, destination))
			return false;
		boolean result = copyContents(node, source, destination);

		// fix bug 217489
		((Workspace) source.getWorkspace()).getCopyMap()
				.put(Long.valueOf(destination.getResourceInfo(false, false).getNodeId()), source);
		return result;
	}

	protected boolean copyContents(UnifiedTreeNode node, Resource source, Resource destination) {




package org.eclipse.core.internal.resources;

import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;

import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileInfo;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.internal.events.LifecycleEvent;
import org.eclipse.core.internal.utils.FileUtil;
import org.eclipse.core.internal.utils.Messages;
import org.eclipse.core.internal.utils.Policy;
import org.eclipse.core.resources.IBuildConfiguration;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IProjectNature;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.ISaveContext;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.team.IMoveDeleteHook;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.ICoreRunnable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.content.IContentTypeMatcher;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;

				// write out the new project description to the meta area
				try {
					destination.writeDescription(IResource.FORCE);
					// fix bug 217489
					Resource descFileSource = (Resource) getFile(IProjectDescription.DESCRIPTION_FILE_NAME);
					Resource descFileDest = (Resource) destination.getFile(IProjectDescription.DESCRIPTION_FILE_NAME);
					// For tracking COPIED_FROM
					workspace.getCopyMap().put(Long.valueOf(descFileDest.getResourceInfo(false, false).getNodeId()),
							descFileSource);

				} catch (CoreException e) {
					try {
						destination.delete((updateFlags & IResource.FORCE) != 0, null);





import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileInfo;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.filesystem.provider.FileInfo;
import org.eclipse.core.internal.events.LifecycleEvent;
import org.eclipse.core.internal.localstore.FileSystemResourceManager;
import org.eclipse.core.internal.properties.IPropertyManager;
import org.eclipse.core.internal.utils.FileUtil;
import org.eclipse.core.internal.utils.Messages;
import org.eclipse.core.internal.utils.WrappedRuntimeException;
import org.eclipse.core.internal.watson.ElementTreeIterator;
import org.eclipse.core.internal.watson.IElementContentVisitor;
import org.eclipse.core.internal.watson.IPathRequestor;
import org.eclipse.core.resources.FileInfoMatcherDescription;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IPathVariableManager;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceProxy;
import org.eclipse.core.resources.IResourceProxyVisitor;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.IResourceVisitor;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourceAttributes;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.team.IMoveDeleteHook;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.PlatformObject;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.MultiRule;
import org.eclipse.osgi.util.NLS;

			try {
				boolean shouldContinue = true;
				switch (depth) {
				case DEPTH_ZERO :
					shouldContinue = false;
					break;
				case DEPTH_ONE :
					shouldContinue = !path.equals(requestor.requestPath().removeLastSegments(1));
					break;
				case DEPTH_INFINITE :
					shouldContinue = true;
					break;
				}
				return visitor.visit(proxy) && shouldContinue;
			} catch (CoreException e) {


			// Copy over the properties.
			getPropertyManager().copy(this, destProject, DEPTH_ZERO);

			// fix bug 217489
			// For tracking COPIED_FROM
			workspace.getCopyMap().put(Long.valueOf(destProject.getResourceInfo(false, false).getNodeId()), this);

			progress.split(18);
		} catch (OperationCanceledException e) {
			workspace.getWorkManager().operationCanceled();


	public String getTypeString() {
		switch (getType()) {
		case FILE :
			return "L"; //$NON-NLS-1$
		case FOLDER :
			return "F"; //$NON-NLS-1$
		case PROJECT :
			return "P"; //$NON-NLS-1$
		case ROOT :
			return "R"; //$NON-NLS-1$
		}
		return ""; //$NON-NLS-1$
	}


	private void broadcastPreDeleteEvent() throws CoreException {
		switch (getType()) {
		case IResource.PROJECT :
			workspace.broadcastEvent(LifecycleEvent.newEvent(LifecycleEvent.PRE_PROJECT_DELETE, this));
			break;
		case IResource.ROOT :
			// All root children including hidden projects will be deleted so notify.
			IResource[] projects = ((Container) this).getChildren(IContainer.INCLUDE_HIDDEN);
			for (IResource project2 : projects) {
				workspace.broadcastEvent(LifecycleEvent.newEvent(LifecycleEvent.PRE_PROJECT_DELETE, project2));
			}
			break;
		}
	}

	private void broadcastPreMoveEvent(final IResource destination, int updateFlags) throws CoreException {
		switch (getType()) {
		case IResource.FILE :
			if (isLinked())
				workspace.broadcastEvent(LifecycleEvent.newEvent(LifecycleEvent.PRE_LINK_MOVE, this, destination, updateFlags));
			break;
		case IResource.FOLDER :
			if (isLinked())
				workspace.broadcastEvent(LifecycleEvent.newEvent(LifecycleEvent.PRE_LINK_MOVE, this, destination, updateFlags));
			if (isVirtual())
				workspace.broadcastEvent(LifecycleEvent.newEvent(LifecycleEvent.PRE_GROUP_MOVE, this, destination, updateFlags));
			break;
		case IResource.PROJECT :
			if (!getName().equals(destination.getName())) {
				// If there is a change in name, we are deleting the source project so notify.
				workspace.broadcastEvent(LifecycleEvent.newEvent(LifecycleEvent.PRE_PROJECT_MOVE, this, destination, updateFlags));
			}
			break;
		}
	}





import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Predicate;

import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.internal.events.BuildManager;
import org.eclipse.core.internal.events.ILifecycleListener;
import org.eclipse.core.internal.events.LifecycleEvent;
import org.eclipse.core.internal.events.NotificationManager;
import org.eclipse.core.internal.events.ResourceChangeEvent;
import org.eclipse.core.internal.events.ResourceComparator;
import org.eclipse.core.internal.localstore.FileSystemResourceManager;
import org.eclipse.core.internal.preferences.PreferencesService;
import org.eclipse.core.internal.properties.IPropertyManager;

import org.eclipse.core.internal.refresh.RefreshManager;
import org.eclipse.core.internal.resources.ComputeProjectOrder.Digraph;
import org.eclipse.core.internal.resources.ComputeProjectOrder.VertexOrder;
import org.eclipse.core.internal.utils.Messages;
import org.eclipse.core.internal.utils.Policy;
import org.eclipse.core.internal.utils.StringPoolJob;
import org.eclipse.core.internal.watson.ElementTree;
import org.eclipse.core.internal.watson.ElementTreeIterator;
import org.eclipse.core.internal.watson.IElementContentVisitor;
import org.eclipse.core.resources.IBuildConfiguration;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFileModificationValidator;
import org.eclipse.core.resources.IFilterMatcherDescriptor;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IPathVariableManager;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IProjectNatureDescriptor;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceRuleFactory;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.ISaveContext;
import org.eclipse.core.resources.ISaveParticipant;
import org.eclipse.core.resources.ISavedState;
import org.eclipse.core.resources.ISynchronizer;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ProjectScope;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.team.FileModificationValidationContext;
import org.eclipse.core.resources.team.FileModificationValidator;
import org.eclipse.core.resources.team.IMoveDeleteHook;
import org.eclipse.core.resources.team.TeamHook;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.ICoreRunnable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.PlatformObject;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.JobGroup;
import org.eclipse.osgi.util.NLS;
import org.osgi.framework.Bundle;
import org.xml.sax.InputSource;

	protected IFileModificationValidator validator = null;

	/**
	 * Map K(new resource node Id (Long)) V(old resource (Resource)) used to 
	 * find the resource that was copied from.  Used only during Resource.copy()
	 * We use the nodeId as the key so we don't have to create a resource
	 * when checking the map during delta computation.  The value can be a resource
	 * because that's already available during the copy.
	 * 
	 * The copyMap is created automatically when first written to, and removed at
	 * the end of the top level operation if it exists.
	 * 
	 * fix bug 217489
	 */
	protected Map<Long, IResource> copyMap;

	/**
	 * Data structure for holding the multi-part outcome of
	 * <code>IWorkspace.computeProjectBuildConfigOrder</code>.
	 * <p>

			project.writeDescription(updateFlags);
		}

		// For tracking COPIED_FROM
		getCopyMap().put(Long.valueOf(newInfo.getNodeId()), source);

		// do the recursion. if we have a file then it has no members so return. otherwise
		// recursively call this method on the container's members if the depth tells us to
		if (depth == IResource.DEPTH_ZERO || source.getType() == IResource.FILE)


		IPath srcValue = URIUtil.toPath(srcPathVariableManager.getURIValue(variable));
		if (srcValue == null) // if the variable doesn't exist, return another
			// variable that doesn't exist either
			return PathVariableUtil.getUniqueVariableName(variable, dest);
		IPath resolvedSrcValue = URIUtil.toPath(srcPathVariableManager.resolveURI(URIUtil.toURI(srcValue)));


		if (!tree.includes(root))
			return 0;
		switch (depth) {
		case IResource.DEPTH_ZERO :
			return 1;
		case IResource.DEPTH_ONE :
			return 1 + tree.getChildCount(root);
		case IResource.DEPTH_INFINITE :
			final int[] count = new int[1];
			IElementContentVisitor visitor = (aTree, requestor, elementContents) -> {
				if (phantom || !((ResourceInfo) elementContents).isSet(M_PHANTOM))
					count[0]++;
				return true;
			};
			new ElementTreeIterator(tree, root).iterate(visitor);
			return count[0];
		}
		return 0;
	}

		for (IProject project : projects) {
			if (!project.isAccessible()) {
				continue;
			}
			IProject[] refs = ((Project)project).internalGetDescription().getReferencedProjects(false);
			List<IProject> dangling = new ArrayList<>(refs.length);
			for (IProject ref : refs) {

			//create anonymous subclass because TeamHook is abstract
			if (teamHook == null)
				teamHook = new TeamHook() {
				// empty
			};
		}
	}


	protected ResourceInfo newElement(int type) {
		ResourceInfo result = null;
		switch (type) {
		case IResource.FILE :
		case IResource.FOLDER :
			result = new ResourceInfo();
			break;
		case IResource.PROJECT :
			result = new ProjectInfo();
			break;
		case IResource.ROOT :
			result = new RootInfo();
			break;
		}
		result.setNodeId(nextNodeId());
		updateModificationStamp(result);

	public Resource newResource(IPath path, int type) {
		String message;
		switch (type) {
		case IResource.FOLDER :
			if (path.segmentCount() < ICoreConstants.MINIMUM_FOLDER_SEGMENT_LENGTH) {
				message = "Path must include project and resource name: " + path.toString(); //$NON-NLS-1$
				Assert.isLegal(false, message);
			}
			return new Folder(path.makeAbsolute(), this);
		case IResource.FILE :
			if (path.segmentCount() < ICoreConstants.MINIMUM_FILE_SEGMENT_LENGTH) {
				message = "Path must include project and resource name: " + path.toString(); //$NON-NLS-1$
				Assert.isLegal(false, message);
			}
			return new File(path.makeAbsolute(), this);
		case IResource.PROJECT :
			return (Resource) getRoot().getProject(path.lastSegment());
		case IResource.ROOT :
			return (Resource) getRoot();
		}
		Assert.isLegal(false);
		// will never get here because of assertion.

		}
		return Status.OK_STATUS;
	}

	public Map<Long, IResource> getCopyMap() {
		if (copyMap == null)
			copyMap = new HashMap<>();
		return copyMap;
	}

	public Map<Long, IResource> getCopyMapRead() {
		// Don't create it
		return copyMap;
	}
}

Return to bug 217489

Lines 15-23 Link Here

(-)designer/bundles/patch/eclipse/org.eclipse.core.resources/src/org/eclipse/core/internal/events/ResourceDeltaFactory.java (-16 / +30 lines)
15	package org.eclipse.core.internal.events;	15	package org.eclipse.core.internal.events;
16		16
17	import java.util.Map;	17	import java.util.Map;
		18
18	import org.eclipse.core.internal.dtree.DeltaDataTree;	19	import org.eclipse.core.internal.dtree.DeltaDataTree;
19	import org.eclipse.core.internal.dtree.NodeComparison;	20	import org.eclipse.core.internal.dtree.NodeComparison;
20	import org.eclipse.core.internal.resources.*;	21	import org.eclipse.core.internal.resources.ICoreConstants;
		22	import org.eclipse.core.internal.resources.MarkerSet;
		23	import org.eclipse.core.internal.resources.Project;
		24	import org.eclipse.core.internal.resources.Resource;
		25	import org.eclipse.core.internal.resources.ResourceInfo;
		26	import org.eclipse.core.internal.resources.Workspace;
21	import org.eclipse.core.internal.watson.ElementTree;	27	import org.eclipse.core.internal.watson.ElementTree;
22	import org.eclipse.core.resources.IProject;	28	import org.eclipse.core.resources.IProject;
23	import org.eclipse.core.resources.IResourceDelta;	29	import org.eclipse.core.resources.IResourceDelta;
Lines 103-123 Link Here
103	ResourceDelta child = (ResourceDelta) element;	109	ResourceDelta child = (ResourceDelta) element;
104	IPath path = child.getFullPath();	110	IPath path = child.getFullPath();
105	switch (child.getKind()) {	111	switch (child.getKind()) {
106	case IResourceDelta.ADDED :	112	case IResourceDelta.ADDED :
107	nodeIDMap.putNewPath(child.newInfo.getNodeId(), path);	113	nodeIDMap.putNewPath(child.newInfo.getNodeId(), path);
108	break;	114	break;
109	case IResourceDelta.REMOVED :	115	case IResourceDelta.REMOVED :
110	nodeIDMap.putOldPath(child.oldInfo.getNodeId(), path);	116	nodeIDMap.putOldPath(child.oldInfo.getNodeId(), path);
111	break;	117	break;
112	case IResourceDelta.CHANGED :	118	case IResourceDelta.CHANGED :
113	long oldID = child.oldInfo.getNodeId();	119	long oldID = child.oldInfo.getNodeId();
114	long newID = child.newInfo.getNodeId();	120	long newID = child.newInfo.getNodeId();
115	//don't add entries to the map if nothing has changed.	121	//don't add entries to the map if nothing has changed.
116	if (oldID != newID) {	122	if (oldID != newID) {
117	nodeIDMap.putOldPath(oldID, path);	123	nodeIDMap.putOldPath(oldID, path);
118	nodeIDMap.putNewPath(newID, path);	124	nodeIDMap.putNewPath(newID, path);
119	}	125	}
120	break;	126	break;
121	}	127	}
122	//recurse	128	//recurse
123	computeNodeIDMap(child, nodeIDMap);	129	computeNodeIDMap(child, nodeIDMap);
Lines 145-150 Link Here
145	result.setOldInfo((ResourceInfo) compare.getOldData());	151	result.setOldInfo((ResourceInfo) compare.getOldData());
146	result.setNewInfo((ResourceInfo) compare.getNewData());	152	result.setNewInfo((ResourceInfo) compare.getNewData());
147	}	153	}
		154	// fix bug 217489
		155	// See if this is a copy and get the info
		156	if (comparison == IResourceDelta.ADDED && workspace.getCopyMapRead() != null) {
		157	Resource sourceRes = (Resource) workspace.getCopyMapRead().get(Long.valueOf(result.newInfo.getNodeId()));
		158	if (sourceRes != null)
		159	result.setOldInfo(sourceRes.getResourceInfo(false, false));
		160	}
		161
148	// recurse over the children	162	// recurse over the children
149	IPath[] childKeys = delta.getChildren(pathInDelta);	163	IPath[] childKeys = delta.getChildren(pathInDelta);
150	int numChildren = childKeys.length;	164	int numChildren = childKeys.length;

Lines 11-27 Link Here

(-)designer/bundles/patch/eclipse/org.eclipse.core.resources/src/org/eclipse/core/internal/localstore/CopyVisitor.java (-5 / +26 lines)
11	* Contributors:	11	* Contributors:
12	* IBM Corporation - initial API and implementation	12	* IBM Corporation - initial API and implementation
13	* Serge Beauchamp (Freescale Semiconductor) - [252996] add resource filtering	13	* Serge Beauchamp (Freescale Semiconductor) - [252996] add resource filtering
14	*******************************************************************************/	14	*******************************************************************************/
15	package org.eclipse.core.internal.localstore;	15	package org.eclipse.core.internal.localstore;
16		16
17	import java.net.URI;	17	import java.net.URI;
18	import java.util.LinkedList;	18	import java.util.LinkedList;
		19
19	import org.eclipse.core.filesystem.EFS;	20	import org.eclipse.core.filesystem.EFS;
20	import org.eclipse.core.filesystem.IFileStore;	21	import org.eclipse.core.filesystem.IFileStore;
21	import org.eclipse.core.internal.resources.*;	22	import org.eclipse.core.internal.resources.Container;
		23	import org.eclipse.core.internal.resources.File;
		24	import org.eclipse.core.internal.resources.FilterDescription;
		25	import org.eclipse.core.internal.resources.Folder;
		26	import org.eclipse.core.internal.resources.Project;
		27	import org.eclipse.core.internal.resources.Resource;
		28	import org.eclipse.core.internal.resources.ResourceInfo;
		29	import org.eclipse.core.internal.resources.ResourceStatus;
		30	import org.eclipse.core.internal.resources.Workspace;
22	import org.eclipse.core.internal.utils.Messages;	31	import org.eclipse.core.internal.utils.Messages;
23	import org.eclipse.core.resources.*;	32	import org.eclipse.core.resources.IResource;
24	import org.eclipse.core.runtime.*;	33	import org.eclipse.core.resources.IResourceStatus;
		34	import org.eclipse.core.resources.ResourcesPlugin;
		35	import org.eclipse.core.runtime.CoreException;
		36	import org.eclipse.core.runtime.IPath;
		37	import org.eclipse.core.runtime.IProgressMonitor;
		38	import org.eclipse.core.runtime.IStatus;
		39	import org.eclipse.core.runtime.MultiStatus;
		40	import org.eclipse.core.runtime.SubMonitor;
25	import org.eclipse.osgi.util.NLS;	41	import org.eclipse.osgi.util.NLS;
26		42
27	//	43	//
Lines 70-76 Link Here
70	Resource destination = getDestinationResource(source, sufix);	86	Resource destination = getDestinationResource(source, sufix);
71	if (!copyProperties(source, destination))	87	if (!copyProperties(source, destination))
72	return false;	88	return false;
73	return copyContents(node, source, destination);	89	boolean result = copyContents(node, source, destination);
		90
		91	// fix bug 217489
		92	((Workspace) source.getWorkspace()).getCopyMap()
		93	.put(Long.valueOf(destination.getResourceInfo(false, false).getNodeId()), source);
		94	return result;
74	}	95	}
75		96
76	protected boolean copyContents(UnifiedTreeNode node, Resource source, Resource destination) {	97	protected boolean copyContents(UnifiedTreeNode node, Resource source, Resource destination) {

Lines 20-32 Link Here

(-)designer/bundles/patch/eclipse/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/Project.java (-5 / +44 lines)
20	package org.eclipse.core.internal.resources;	20	package org.eclipse.core.internal.resources;
21		21
22	import java.net.URI;	22	import java.net.URI;
23	import java.util.*;	23	import java.util.ArrayList;
24	import org.eclipse.core.filesystem.*;	24	import java.util.Arrays;
		25	import java.util.Collection;
		26	import java.util.HashMap;
		27	import java.util.LinkedHashSet;
		28	import java.util.List;
		29	import java.util.Map;
		30	import java.util.TreeSet;
		31
		32	import org.eclipse.core.filesystem.EFS;
		33	import org.eclipse.core.filesystem.IFileInfo;
		34	import org.eclipse.core.filesystem.IFileStore;
25	import org.eclipse.core.internal.events.LifecycleEvent;	35	import org.eclipse.core.internal.events.LifecycleEvent;
26	import org.eclipse.core.internal.utils.*;	36	import org.eclipse.core.internal.utils.FileUtil;
27	import org.eclipse.core.resources.*;	37	import org.eclipse.core.internal.utils.Messages;
		38	import org.eclipse.core.internal.utils.Policy;
		39	import org.eclipse.core.resources.IBuildConfiguration;
		40	import org.eclipse.core.resources.IContainer;
		41	import org.eclipse.core.resources.IProject;
		42	import org.eclipse.core.resources.IProjectDescription;
		43	import org.eclipse.core.resources.IProjectNature;
		44	import org.eclipse.core.resources.IResource;
		45	import org.eclipse.core.resources.IResourceChangeEvent;
		46	import org.eclipse.core.resources.IResourceStatus;
		47	import org.eclipse.core.resources.ISaveContext;
		48	import org.eclipse.core.resources.IWorkspace;
		49	import org.eclipse.core.resources.ResourcesPlugin;
28	import org.eclipse.core.resources.team.IMoveDeleteHook;	50	import org.eclipse.core.resources.team.IMoveDeleteHook;
29	import org.eclipse.core.runtime.*;	51	import org.eclipse.core.runtime.Assert;
		52	import org.eclipse.core.runtime.CoreException;
		53	import org.eclipse.core.runtime.ICoreRunnable;
		54	import org.eclipse.core.runtime.IPath;
		55	import org.eclipse.core.runtime.IProgressMonitor;
		56	import org.eclipse.core.runtime.IStatus;
		57	import org.eclipse.core.runtime.MultiStatus;
		58	import org.eclipse.core.runtime.OperationCanceledException;
		59	import org.eclipse.core.runtime.Path;
		60	import org.eclipse.core.runtime.Status;
		61	import org.eclipse.core.runtime.SubMonitor;
30	import org.eclipse.core.runtime.content.IContentTypeMatcher;	62	import org.eclipse.core.runtime.content.IContentTypeMatcher;
31	import org.eclipse.core.runtime.jobs.ISchedulingRule;	63	import org.eclipse.core.runtime.jobs.ISchedulingRule;
32	import org.eclipse.core.runtime.jobs.Job;	64	import org.eclipse.core.runtime.jobs.Job;
Lines 690-695 Link Here
690	// write out the new project description to the meta area	722	// write out the new project description to the meta area
691	try {	723	try {
692	destination.writeDescription(IResource.FORCE);	724	destination.writeDescription(IResource.FORCE);
		725	// fix bug 217489
		726	Resource descFileSource = (Resource) getFile(IProjectDescription.DESCRIPTION_FILE_NAME);
		727	Resource descFileDest = (Resource) destination.getFile(IProjectDescription.DESCRIPTION_FILE_NAME);
		728	// For tracking COPIED_FROM
		729	workspace.getCopyMap().put(Long.valueOf(descFileDest.getResourceInfo(false, false).getNodeId()),
		730	descFileSource);
		731
693	} catch (CoreException e) {	732	} catch (CoreException e) {
694	try {	733	try {
695	destination.delete((updateFlags & IResource.FORCE) != 0, null);	734	destination.delete((updateFlags & IResource.FORCE) != 0, null);

Lines 22-34 Link Here

(-)designer/bundles/patch/eclipse/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/Workspace.java (-51 / +151 lines)
22	import java.io.InputStream;	22	import java.io.InputStream;
23	import java.net.URI;	23	import java.net.URI;
24	import java.net.URISyntaxException;	24	import java.net.URISyntaxException;
25	import java.util.*;	25	import java.util.ArrayDeque;
		26	import java.util.ArrayList;
		27	import java.util.Arrays;
		28	import java.util.Collection;
		29	import java.util.Comparator;
		30	import java.util.Deque;
		31	import java.util.HashMap;
		32	import java.util.HashSet;
		33	import java.util.Iterator;
		34	import java.util.LinkedHashSet;
		35	import java.util.LinkedList;
		36	import java.util.List;
		37	import java.util.Map;
		38	import java.util.Set;
		39	import java.util.SortedSet;
		40	import java.util.TreeSet;
26	import java.util.concurrent.CopyOnWriteArrayList;	41	import java.util.concurrent.CopyOnWriteArrayList;
27	import java.util.function.Predicate;	42	import java.util.function.Predicate;
		43
28	import org.eclipse.core.filesystem.EFS;	44	import org.eclipse.core.filesystem.EFS;
29	import org.eclipse.core.filesystem.IFileStore;	45	import org.eclipse.core.filesystem.IFileStore;
30	import org.eclipse.core.filesystem.URIUtil;	46	import org.eclipse.core.filesystem.URIUtil;
31	import org.eclipse.core.internal.events.*;	47	import org.eclipse.core.internal.events.BuildManager;
		48	import org.eclipse.core.internal.events.ILifecycleListener;
		49	import org.eclipse.core.internal.events.LifecycleEvent;
		50	import org.eclipse.core.internal.events.NotificationManager;
		51	import org.eclipse.core.internal.events.ResourceChangeEvent;
		52	import org.eclipse.core.internal.events.ResourceComparator;
32	import org.eclipse.core.internal.localstore.FileSystemResourceManager;	53	import org.eclipse.core.internal.localstore.FileSystemResourceManager;
33	import org.eclipse.core.internal.preferences.PreferencesService;	54	import org.eclipse.core.internal.preferences.PreferencesService;
34	import org.eclipse.core.internal.properties.IPropertyManager;	55	import org.eclipse.core.internal.properties.IPropertyManager;
Lines 36-47 Link Here
36	import org.eclipse.core.internal.refresh.RefreshManager;	57	import org.eclipse.core.internal.refresh.RefreshManager;
37	import org.eclipse.core.internal.resources.ComputeProjectOrder.Digraph;	58	import org.eclipse.core.internal.resources.ComputeProjectOrder.Digraph;
38	import org.eclipse.core.internal.resources.ComputeProjectOrder.VertexOrder;	59	import org.eclipse.core.internal.resources.ComputeProjectOrder.VertexOrder;
39	import org.eclipse.core.internal.utils.*;	60	import org.eclipse.core.internal.utils.Messages;
40	import org.eclipse.core.internal.watson.*;	61	import org.eclipse.core.internal.utils.Policy;
41	import org.eclipse.core.resources.*;	62	import org.eclipse.core.internal.utils.StringPoolJob;
42	import org.eclipse.core.resources.team.*;	63	import org.eclipse.core.internal.watson.ElementTree;
43	import org.eclipse.core.runtime.*;	64	import org.eclipse.core.internal.watson.ElementTreeIterator;
44	import org.eclipse.core.runtime.jobs.*;	65	import org.eclipse.core.internal.watson.IElementContentVisitor;
		66	import org.eclipse.core.resources.IBuildConfiguration;
		67	import org.eclipse.core.resources.IContainer;
		68	import org.eclipse.core.resources.IFile;
		69	import org.eclipse.core.resources.IFileModificationValidator;
		70	import org.eclipse.core.resources.IFilterMatcherDescriptor;
		71	import org.eclipse.core.resources.IMarker;
		72	import org.eclipse.core.resources.IPathVariableManager;
		73	import org.eclipse.core.resources.IProject;
		74	import org.eclipse.core.resources.IProjectDescription;
		75	import org.eclipse.core.resources.IProjectNatureDescriptor;
		76	import org.eclipse.core.resources.IResource;
		77	import org.eclipse.core.resources.IResourceChangeEvent;
		78	import org.eclipse.core.resources.IResourceChangeListener;
		79	import org.eclipse.core.resources.IResourceRuleFactory;
		80	import org.eclipse.core.resources.IResourceStatus;
		81	import org.eclipse.core.resources.ISaveContext;
		82	import org.eclipse.core.resources.ISaveParticipant;
		83	import org.eclipse.core.resources.ISavedState;
		84	import org.eclipse.core.resources.ISynchronizer;
		85	import org.eclipse.core.resources.IWorkspace;
		86	import org.eclipse.core.resources.IWorkspaceDescription;
		87	import org.eclipse.core.resources.IWorkspaceRoot;
		88	import org.eclipse.core.resources.IWorkspaceRunnable;
		89	import org.eclipse.core.resources.IncrementalProjectBuilder;
		90	import org.eclipse.core.resources.ProjectScope;
		91	import org.eclipse.core.resources.ResourcesPlugin;
		92	import org.eclipse.core.resources.team.FileModificationValidationContext;
		93	import org.eclipse.core.resources.team.FileModificationValidator;
		94	import org.eclipse.core.resources.team.IMoveDeleteHook;
		95	import org.eclipse.core.resources.team.TeamHook;
		96	import org.eclipse.core.runtime.Assert;
		97	import org.eclipse.core.runtime.CoreException;
		98	import org.eclipse.core.runtime.IConfigurationElement;
		99	import org.eclipse.core.runtime.ICoreRunnable;
		100	import org.eclipse.core.runtime.IPath;
		101	import org.eclipse.core.runtime.IProgressMonitor;
		102	import org.eclipse.core.runtime.ISafeRunnable;
		103	import org.eclipse.core.runtime.IStatus;
		104	import org.eclipse.core.runtime.MultiStatus;
		105	import org.eclipse.core.runtime.NullProgressMonitor;
		106	import org.eclipse.core.runtime.OperationCanceledException;
		107	import org.eclipse.core.runtime.Path;
		108	import org.eclipse.core.runtime.Platform;
		109	import org.eclipse.core.runtime.PlatformObject;
		110	import org.eclipse.core.runtime.Plugin;
		111	import org.eclipse.core.runtime.SafeRunner;
		112	import org.eclipse.core.runtime.Status;
		113	import org.eclipse.core.runtime.SubMonitor;
		114	import org.eclipse.core.runtime.jobs.ISchedulingRule;
		115	import org.eclipse.core.runtime.jobs.Job;
		116	import org.eclipse.core.runtime.jobs.JobGroup;
45	import org.eclipse.osgi.util.NLS;	117	import org.eclipse.osgi.util.NLS;
46	import org.osgi.framework.Bundle;	118	import org.osgi.framework.Bundle;
47	import org.xml.sax.InputSource;	119	import org.xml.sax.InputSource;
Lines 188-193 Link Here
188	protected IFileModificationValidator validator = null;	260	protected IFileModificationValidator validator = null;
189		261
190	/**	262	/**
		263	* Map K(new resource node Id (Long)) V(old resource (Resource)) used to
		264	* find the resource that was copied from. Used only during Resource.copy()
		265	* We use the nodeId as the key so we don't have to create a resource
		266	* when checking the map during delta computation. The value can be a resource
		267	* because that's already available during the copy.
		268	*
		269	* The copyMap is created automatically when first written to, and removed at
		270	* the end of the top level operation if it exists.
		271	*
		272	* fix bug 217489
		273	*/
		274	protected Map<Long, IResource> copyMap;
		275
		276	/**
191	* Data structure for holding the multi-part outcome of	277	* Data structure for holding the multi-part outcome of
192	* <code>IWorkspace.computeProjectBuildConfigOrder</code>.	278	* <code>IWorkspace.computeProjectBuildConfigOrder</code>.
193	* <p>	279	* <p>
Lines 1139-1144 Link Here
1139	project.writeDescription(updateFlags);	1225	project.writeDescription(updateFlags);
1140	}	1226	}
1141		1227
		1228	// For tracking COPIED_FROM
		1229	getCopyMap().put(Long.valueOf(newInfo.getNodeId()), source);
		1230
1142	// do the recursion. if we have a file then it has no members so return. otherwise	1231	// do the recursion. if we have a file then it has no members so return. otherwise
1143	// recursively call this method on the container's members if the depth tells us to	1232	// recursively call this method on the container's members if the depth tells us to
1144	if (depth == IResource.DEPTH_ZERO \|\| source.getType() == IResource.FILE)	1233	if (depth == IResource.DEPTH_ZERO \|\| source.getType() == IResource.FILE)
Lines 1195-1201 Link Here
1195		1284
1196	IPath srcValue = URIUtil.toPath(srcPathVariableManager.getURIValue(variable));	1285	IPath srcValue = URIUtil.toPath(srcPathVariableManager.getURIValue(variable));
1197	if (srcValue == null) // if the variable doesn't exist, return another	1286	if (srcValue == null) // if the variable doesn't exist, return another
1198	// variable that doesn't exist either	1287	// variable that doesn't exist either
1199	return PathVariableUtil.getUniqueVariableName(variable, dest);	1288	return PathVariableUtil.getUniqueVariableName(variable, dest);
1200	IPath resolvedSrcValue = URIUtil.toPath(srcPathVariableManager.resolveURI(URIUtil.toURI(srcValue)));	1289	IPath resolvedSrcValue = URIUtil.toPath(srcPathVariableManager.resolveURI(URIUtil.toURI(srcValue)));
1201		1290
Lines 1276-1294 Link Here
1276	if (!tree.includes(root))	1365	if (!tree.includes(root))
1277	return 0;	1366	return 0;
1278	switch (depth) {	1367	switch (depth) {
1279	case IResource.DEPTH_ZERO :	1368	case IResource.DEPTH_ZERO :
1280	return 1;	1369	return 1;
1281	case IResource.DEPTH_ONE :	1370	case IResource.DEPTH_ONE :
1282	return 1 + tree.getChildCount(root);	1371	return 1 + tree.getChildCount(root);
1283	case IResource.DEPTH_INFINITE :	1372	case IResource.DEPTH_INFINITE :
1284	final int[] count = new int[1];	1373	final int[] count = new int[1];
1285	IElementContentVisitor visitor = (aTree, requestor, elementContents) -> {	1374	IElementContentVisitor visitor = (aTree, requestor, elementContents) -> {
1286	if (phantom \|\| !((ResourceInfo) elementContents).isSet(M_PHANTOM))	1375	if (phantom \|\| !((ResourceInfo) elementContents).isSet(M_PHANTOM))
1287	count[0]++;	1376	count[0]++;
1288	return true;	1377	return true;
1289	};	1378	};
1290	new ElementTreeIterator(tree, root).iterate(visitor);	1379	new ElementTreeIterator(tree, root).iterate(visitor);
1291	return count[0];	1380	return count[0];
1292	}	1381	}
1293	return 0;	1382	return 0;
1294	}	1383	}
Lines 1639-1645 Link Here
1639	for (IProject project : projects) {	1728	for (IProject project : projects) {
1640	if (!project.isAccessible()) {	1729	if (!project.isAccessible()) {
1641	continue;	1730	continue;
1642	}	1731	}
1643	IProject[] refs = ((Project)project).internalGetDescription().getReferencedProjects(false);	1732	IProject[] refs = ((Project)project).internalGetDescription().getReferencedProjects(false);
1644	List<IProject> dangling = new ArrayList<>(refs.length);	1733	List<IProject> dangling = new ArrayList<>(refs.length);
1645	for (IProject ref : refs) {	1734	for (IProject ref : refs) {
Lines 1904-1911 Link Here
1904	//create anonymous subclass because TeamHook is abstract	1993	//create anonymous subclass because TeamHook is abstract
1905	if (teamHook == null)	1994	if (teamHook == null)
1906	teamHook = new TeamHook() {	1995	teamHook = new TeamHook() {
1907	// empty	1996	// empty
1908	};	1997	};
1909	}	1998	}
1910	}	1999	}
1911		2000
Lines 2101-2116 Link Here
2101	protected ResourceInfo newElement(int type) {	2190	protected ResourceInfo newElement(int type) {
2102	ResourceInfo result = null;	2191	ResourceInfo result = null;
2103	switch (type) {	2192	switch (type) {
2104	case IResource.FILE :	2193	case IResource.FILE :
2105	case IResource.FOLDER :	2194	case IResource.FOLDER :
2106	result = new ResourceInfo();	2195	result = new ResourceInfo();
2107	break;	2196	break;
2108	case IResource.PROJECT :	2197	case IResource.PROJECT :
2109	result = new ProjectInfo();	2198	result = new ProjectInfo();
2110	break;	2199	break;
2111	case IResource.ROOT :	2200	case IResource.ROOT :
2112	result = new RootInfo();	2201	result = new RootInfo();
2113	break;	2202	break;
2114	}	2203	}
2115	result.setNodeId(nextNodeId());	2204	result.setNodeId(nextNodeId());
2116	updateModificationStamp(result);	2205	updateModificationStamp(result);
Lines 2133-2154 Link Here
2133	public Resource newResource(IPath path, int type) {	2222	public Resource newResource(IPath path, int type) {
2134	String message;	2223	String message;
2135	switch (type) {	2224	switch (type) {
2136	case IResource.FOLDER :	2225	case IResource.FOLDER :
2137	if (path.segmentCount() < ICoreConstants.MINIMUM_FOLDER_SEGMENT_LENGTH) {	2226	if (path.segmentCount() < ICoreConstants.MINIMUM_FOLDER_SEGMENT_LENGTH) {
2138	message = "Path must include project and resource name: " + path.toString(); //$NON-NLS-1$	2227	message = "Path must include project and resource name: " + path.toString(); //$NON-NLS-1$
2139	Assert.isLegal(false, message);	2228	Assert.isLegal(false, message);
2140	}	2229	}
2141	return new Folder(path.makeAbsolute(), this);	2230	return new Folder(path.makeAbsolute(), this);
2142	case IResource.FILE :	2231	case IResource.FILE :
2143	if (path.segmentCount() < ICoreConstants.MINIMUM_FILE_SEGMENT_LENGTH) {	2232	if (path.segmentCount() < ICoreConstants.MINIMUM_FILE_SEGMENT_LENGTH) {
2144	message = "Path must include project and resource name: " + path.toString(); //$NON-NLS-1$	2233	message = "Path must include project and resource name: " + path.toString(); //$NON-NLS-1$
2145	Assert.isLegal(false, message);	2234	Assert.isLegal(false, message);
2146	}	2235	}
2147	return new File(path.makeAbsolute(), this);	2236	return new File(path.makeAbsolute(), this);
2148	case IResource.PROJECT :	2237	case IResource.PROJECT :
2149	return (Resource) getRoot().getProject(path.lastSegment());	2238	return (Resource) getRoot().getProject(path.lastSegment());
2150	case IResource.ROOT :	2239	case IResource.ROOT :
2151	return (Resource) getRoot();	2240	return (Resource) getRoot();
2152	}	2241	}
2153	Assert.isLegal(false);	2242	Assert.isLegal(false);
2154	// will never get here because of assertion.	2243	// will never get here because of assertion.
Lines 2648-2651 Link Here
2648	}	2737	}
2649	return Status.OK_STATUS;	2738	return Status.OK_STATUS;
2650	}	2739	}
		2740
		2741	public Map<Long, IResource> getCopyMap() {
		2742	if (copyMap == null)
		2743	copyMap = new HashMap<>();
		2744	return copyMap;
		2745	}
		2746
		2747	public Map<Long, IResource> getCopyMapRead() {
		2748	// Don't create it
		2749	return copyMap;
		2750	}
2651	}	2751	}