org.eclipse.core.internal.localstore.CopyVisitor Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aspectjtools Show documentation
Show all versions of aspectjtools Show documentation
AspectJ tools most notably contains the AspectJ compiler (AJC). AJC applies aspects to Java classes during
compilation, fully replacing Javac for plain Java classes and also compiling native AspectJ or annotation-based
@AspectJ syntax. Furthermore, AJC can weave aspects into existing class files in a post-compile binary weaving step.
This library is a superset of AspectJ weaver and hence also of AspectJ runtime.
/*******************************************************************************
* Copyright (c) 2000, 2015 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
* 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.*;
import org.eclipse.core.internal.utils.Messages;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.osgi.util.NLS;
//
public class CopyVisitor implements IUnifiedTreeVisitor {
/** root destination */
protected IResource rootDestination;
/** reports progress */
protected SubMonitor monitor;
/** update flags */
protected int updateFlags;
/** force flag */
protected boolean force;
/** deep copy flag */
protected boolean isDeep;
/** segments to drop from the source name */
protected int segmentsToDrop;
/** stores problems encountered while copying */
protected MultiStatus status;
/** visitor to refresh unsynchronized nodes */
protected RefreshLocalVisitor refreshLocalVisitor;
private FileSystemResourceManager localManager;
public CopyVisitor(IResource rootSource, IResource destination, int updateFlags, IProgressMonitor monitor) {
this.localManager = ((Resource) rootSource).getLocalManager();
this.rootDestination = destination;
this.updateFlags = updateFlags;
this.isDeep = (updateFlags & IResource.SHALLOW) == 0;
this.force = (updateFlags & IResource.FORCE) != 0;
this.monitor = SubMonitor.convert(monitor);
this.segmentsToDrop = rootSource.getFullPath().segmentCount();
this.status = new MultiStatus(ResourcesPlugin.PI_RESOURCES, IStatus.INFO, Messages.localstore_copyProblem, null);
}
protected boolean copy(UnifiedTreeNode node) {
Resource source = (Resource) node.getResource();
IPath sufix = source.getFullPath().removeFirstSegments(segmentsToDrop);
Resource destination = getDestinationResource(source, sufix);
if (!copyProperties(source, destination))
return false;
return copyContents(node, source, destination);
}
protected boolean copyContents(UnifiedTreeNode node, Resource source, Resource destination) {
try {
if (source.isVirtual()) {
((Folder) destination).create(IResource.VIRTUAL, true, null);
return true;
}
if ((!isDeep || source.isUnderVirtual()) && source.isLinked()) {
URI sourceLocationURI = getWorkspace().transferVariableDefinition(source, destination, source.getRawLocationURI());
destination.createLink(sourceLocationURI, updateFlags & IResource.ALLOW_MISSING_LOCAL, null);
return false;
}
// update filters in project descriptions
if (source instanceof Container && ((Container) source).hasFilters()) {
Project sourceProject = (Project) source.getProject();
LinkedList originalDescriptions = sourceProject.internalGetDescription().getFilter(source.getProjectRelativePath());
LinkedList filterDescriptions = FilterDescription.copy(originalDescriptions, destination);
Project project = (Project) destination.getProject();
project.internalGetDescription().setFilters(destination.getProjectRelativePath(), filterDescriptions);
project.writeDescription(updateFlags);
}
IFileStore sourceStore = node.getStore();
IFileStore destinationStore = destination.getStore();
//ensure the parent of the root destination exists (bug 126104)
if (destination == rootDestination)
destinationStore.getParent().mkdir(EFS.NONE, monitor.newChild(0));
sourceStore.copy(destinationStore, EFS.SHALLOW, monitor.newChild(0));
//create the destination in the workspace
ResourceInfo info = localManager.getWorkspace().createResource(destination, updateFlags);
localManager.updateLocalSync(info, destinationStore.fetchInfo().getLastModified());
//update timestamps on aliases
getWorkspace().getAliasManager().updateAliases(destination, destinationStore, IResource.DEPTH_ZERO, monitor);
if (destination.getType() == IResource.FILE)
((File) destination).updateMetadataFiles();
} catch (CoreException e) {
status.add(e.getStatus());
}
return true;
}
protected boolean copyProperties(Resource target, Resource destination) {
try {
target.getPropertyManager().copy(target, destination, IResource.DEPTH_ZERO);
return true;
} catch (CoreException e) {
status.add(e.getStatus());
return false;
}
}
protected Resource getDestinationResource(Resource source, IPath suffix) {
if (suffix.segmentCount() == 0)
return (Resource) rootDestination;
IPath destinationPath = rootDestination.getFullPath().append(suffix);
return getWorkspace().newResource(destinationPath, source.getType());
}
/**
* This is done in order to generate less garbage.
*/
protected RefreshLocalVisitor getRefreshLocalVisitor() {
if (refreshLocalVisitor == null)
refreshLocalVisitor = new RefreshLocalVisitor(SubMonitor.convert(null));
return refreshLocalVisitor;
}
public IStatus getStatus() {
return status;
}
protected Workspace getWorkspace() {
return (Workspace) rootDestination.getWorkspace();
}
protected boolean isSynchronized(UnifiedTreeNode node) {
/* virtual resources are always deemed as being synchronized */
if (node.getResource().isVirtual())
return true;
if (node.isErrorInFileSystem())
return true; // Assume synchronized unless proven otherwise
/* does the resource exist in workspace and file system? */
if (!node.existsInWorkspace() || !node.existsInFileSystem())
return false;
/* we don't care about folder last modified */
if (node.isFolder() && node.getResource().getType() == IResource.FOLDER)
return true;
/* is lastModified different? */
Resource target = (Resource) node.getResource();
long lastModifed = target.getResourceInfo(false, false).getLocalSyncInfo();
if (lastModifed != node.getLastModified())
return false;
return true;
}
protected void synchronize(UnifiedTreeNode node) throws CoreException {
getRefreshLocalVisitor().visit(node);
}
@Override
public boolean visit(UnifiedTreeNode node) throws CoreException {
monitor.checkCanceled();
int work = 1;
try {
//location can be null if based on an undefined variable
if (node.getStore() == null) {
//should still be a best effort copy
IPath path = node.getResource().getFullPath();
String message = NLS.bind(Messages.localstore_locationUndefined, path);
status.add(new ResourceStatus(IResourceStatus.FAILED_READ_LOCAL, path, message, null));
return false;
}
boolean wasSynchronized = isSynchronized(node);
if (force && !wasSynchronized) {
synchronize(node);
// If not synchronized, the monitor did not take this resource into account.
// So, do not report work on it.
work = 0;
//if source still doesn't exist, then fail because we can't copy a missing resource
if (!node.existsInFileSystem()) {
IPath path = node.getResource().getFullPath();
String message = NLS.bind(Messages.resources_mustExist, path);
status.add(new ResourceStatus(IResourceStatus.RESOURCE_NOT_FOUND, path, message, null));
return false;
}
}
if (!force && !wasSynchronized) {
IPath path = node.getResource().getFullPath();
String message = NLS.bind(Messages.localstore_resourceIsOutOfSync, path);
status.add(new ResourceStatus(IResourceStatus.OUT_OF_SYNC_LOCAL, path, message, null));
return true;
}
return copy(node);
} finally {
monitor.worked(work);
}
}
}