package org.eclipse.team.core.subscribers;
import java.util.HashSet;
import java.util.Set;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.resources.mapping.RemoteResourceMappingContext;
import org.eclipse.core.resources.mapping.ResourceTraversal;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.core.synchronize.SyncInfo;
import org.eclipse.team.core.variants.IResourceVariant;
import org.eclipse.team.internal.core.Messages;
import org.eclipse.team.internal.core.Policy;
import org.eclipse.team.internal.core.TeamPlugin;
public class SubscriberResourceMappingContext extends RemoteResourceMappingContext {
private final Subscriber subscriber;
private Set<IResource> shallowRefresh = new HashSet<>();
private Set<IResource> deepRefresh = new HashSet<>();
private boolean autoRefresh;
public static RemoteResourceMappingContext createContext(Subscriber subscriber) {
return new SubscriberResourceMappingContext(subscriber, true);
}
public SubscriberResourceMappingContext(Subscriber subscriber, boolean autoRefresh) {
this.subscriber = subscriber;
this.autoRefresh = autoRefresh;
}
@Override
public final boolean hasRemoteChange(IResource resource, IProgressMonitor monitor) throws CoreException {
try {
monitor.beginTask(null, 100);
ensureRefreshed(resource, IResource.DEPTH_ONE, NONE, monitor);
SyncInfo syncInfo = subscriber.getSyncInfo(resource);
validateRemote(resource, syncInfo);
if (syncInfo == null) return false;
int direction = SyncInfo.getDirection(syncInfo.getKind());
return direction == SyncInfo.INCOMING || direction == SyncInfo.CONFLICTING;
} finally {
monitor.done();
}
}
@Override
public boolean hasLocalChange(IResource resource, IProgressMonitor monitor) throws CoreException {
SyncInfo syncInfo = subscriber.getSyncInfo(resource);
if (syncInfo == null) return false;
int direction = SyncInfo.getDirection(syncInfo.getKind());
return direction == SyncInfo.OUTGOING || direction == SyncInfo.CONFLICTING;
}
@Override
public final IStorage fetchRemoteContents(IFile file, IProgressMonitor monitor) throws CoreException {
try {
monitor.beginTask(null, 100);
ensureRefreshed(file, IResource.DEPTH_ZERO, FILE_CONTENTS_REQUIRED, Policy.subMonitorFor(monitor, 10));
SyncInfo syncInfo = subscriber.getSyncInfo(file);
IResourceVariant remote = validateRemote(file, syncInfo);
if (remote == null) {
return null;
}
return remote.getStorage(Policy.subMonitorFor(monitor, 90));
} finally {
monitor.done();
}
}
@Override
public final IStorage fetchBaseContents(IFile file, IProgressMonitor monitor) throws CoreException {
try {
monitor.beginTask(null, 100);
ensureRefreshed(file, IResource.DEPTH_ZERO, FILE_CONTENTS_REQUIRED, Policy.subMonitorFor(monitor, 10));
SyncInfo syncInfo = subscriber.getSyncInfo(file);
IResourceVariant base = validateBase(file, syncInfo);
if (base == null) {
return null;
}
return base.getStorage(Policy.subMonitorFor(monitor, 90));
} finally {
monitor.done();
}
}
@Override
public final IResource[] fetchMembers(IContainer container, IProgressMonitor monitor) throws CoreException {
try {
monitor.beginTask(null, 100);
ensureRefreshed(container, IResource.DEPTH_ONE, NONE, Policy.subMonitorFor(monitor, 100));
SyncInfo syncInfo = subscriber.getSyncInfo(container);
if (validateRemote(container, syncInfo) == null) {
return new IResource[0];
}
return subscriber.members(container);
} finally {
monitor.done();
}
}
@Override
public final void refresh(ResourceTraversal[] traversals, int flags, IProgressMonitor monitor) throws CoreException {
subscriber.refresh(traversals, monitor);
for (ResourceTraversal traversal : traversals) {
refreshed(traversal.getResources(), traversal.getDepth());
}
}
protected void refresh(IResource[] resources, int depth, int flags, IProgressMonitor monitor) throws TeamException {
subscriber.refresh(resources, depth, monitor);
refreshed(resources, depth);
}
protected final void refreshed(IResource[] resources, int depth) {
for (IResource resource : resources) {
if (depth == IResource.DEPTH_ONE || resource.getType() == IResource.FILE) {
shallowRefresh.add(resource);
} else if (depth == IResource.DEPTH_INFINITE) {
deepRefresh.add(resource);
}
}
}
private void ensureRefreshed(IResource resource, int depth, int flags, IProgressMonitor monitor) throws TeamException {
if (autoRefresh) {
if (depth == IResource.DEPTH_INFINITE) {
if (wasRefreshedDeeply(resource))
return;
if (resource.getType() == IResource.FILE && wasRefreshedShallow(resource))
return;
} else {
if (wasRefreshedShallow(resource))
return;
}
refresh(new IResource[] { resource }, depth, flags, monitor);
}
}
private boolean wasRefreshedShallow(IResource resource) {
if (shallowRefresh.contains(resource))
return true;
if (resource.getType() == IResource.FILE && shallowRefresh.contains(resource.getParent()))
return true;
if (wasRefreshedDeeply(resource))
return true;
return false;
}
private boolean wasRefreshedDeeply(IResource resource) {
if (resource.getType() == IResource.ROOT)
return false;
if (deepRefresh.contains(resource))
return true;
return wasRefreshedDeeply(resource.getParent());
}
private IResourceVariant validateRemote(IResource resource, SyncInfo syncInfo) throws CoreException {
if (syncInfo == null) return null;
IResourceVariant remote = syncInfo.getRemote();
if (remote == null) return null;
return validateRemote(resource, remote);
}
private IResourceVariant validateRemote(IResource resource, IResourceVariant remote) throws CoreException {
boolean containerExpected = resource.getType() != IResource.FILE;
if (remote.isContainer() && !containerExpected) {
throw new CoreException(new Status(IStatus.ERROR, TeamPlugin.ID, IResourceStatus.RESOURCE_WRONG_TYPE, Messages.SubscriberResourceMappingContext_0 + resource.getFullPath().toString(), null));
} else if (!remote.isContainer() && containerExpected) {
throw new CoreException(new Status(IStatus.ERROR, TeamPlugin.ID, IResourceStatus.RESOURCE_WRONG_TYPE, Messages.SubscriberResourceMappingContext_1 + resource.getFullPath().toString(), null));
}
return remote;
}
private IResourceVariant validateBase(IResource resource, SyncInfo syncInfo) throws CoreException {
if (syncInfo == null) return null;
IResourceVariant base = syncInfo.getBase();
if (base == null) return null;
return validateRemote(resource, base);
}
public void setAutoRefresh(boolean autoRefresh) {
this.autoRefresh = autoRefresh;
}
@Override
public boolean isThreeWay() {
return subscriber.getResourceComparator().isThreeWay();
}
public boolean contentDiffers(IFile file, IProgressMonitor monitor) throws CoreException {
return hasRemoteChange(file, monitor) || hasLocalChange(file, monitor);
}
@Override
public IProject[] getProjects() {
Set<IProject> projects = new HashSet<>();
IResource[] roots = subscriber.roots();
for (IResource resource : roots) {
projects.add(resource.getProject());
}
return projects.toArray(new IProject[projects.size()]);
}
}