Java SVNWorkspaceRoot类代码示例

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
private SVNTreeConflict getTreeConflict(final IResource resource) {
	treeConflict = null;
	BusyIndicator.showWhile(Display.getDefault(), new Runnable() {
		public void run() {
			ISVNClientAdapter client = null;
			try {
				client = SVNWorkspaceRoot.getSVNResourceFor(resource).getRepository().getSVNClient();
				ISVNStatus[] statuses = client.getStatus(resource.getLocation().toFile(), true, true, true);
				for (int i = 0; i < statuses.length; i++) {
					if (statuses[i].hasTreeConflict()) {
						treeConflict = new SVNTreeConflict(statuses[i]);
						break;
					}
				}
			} catch (Exception e) {
				SVNUIPlugin.log(IStatus.ERROR, e.getMessage(), e);
			}
			finally {
				SVNWorkspaceRoot.getSVNResourceFor(resource).getRepository().returnSVNClient(client);
			}
		}			
	});
	return treeConflict;
}
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
private SVNTreeConflict getTreeConflict(final IResource resource) {
	BusyIndicator.showWhile(Display.getDefault(), new Runnable() {
		public void run() {
			ISVNClientAdapter client = null;
			try {
				client = SVNWorkspaceRoot.getSVNResourceFor(resource).getRepository().getSVNClient();
				ISVNStatus[] statuses = client.getStatus(resource.getLocation().toFile(), true, true, true);
				for (int i = 0; i < statuses.length; i++) {
					if (statuses[i].hasTreeConflict()) {
						treeConflict = new SVNTreeConflict(statuses[i]);
						break;
					}
				}
			} catch (Exception e) {
				SVNUIPlugin.log(IStatus.ERROR, e.getMessage(), e);
			}
			finally {
				SVNWorkspaceRoot.getSVNResourceFor(resource).getRepository().returnSVNClient(client);
			}
		}			
	});
	return treeConflict;
}
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
protected boolean isEnabledForMultipleResources() {
	try {
		// Must all be from same repository.
		ISVNRepositoryLocation repository = null;
		IResource[] selectedResources = getSelectedResources();
		for (int i = 0; i < selectedResources.length; i++) {
			ISVNRepositoryLocation compareToRepository = null;
			ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(selectedResources[i]);
			if (svnResource == null || !svnResource.isManaged()) {
				return false;
			}
			LocalResourceStatus status = svnResource.getStatusFromCache();
			if (status != null) {
				compareToRepository = status.getRepository();
			}
			if (compareToRepository == null) {
				return false;
			}
			if (repository != null && !compareToRepository.equals(repository)) {
				return false;
			}
			repository = compareToRepository;
		}
		return true;
	} catch (Exception e) { return false; }
}
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
public void resourceChanged(IResourceChangeEvent event) {	
	flushCache = false;
	try {
           event.getDelta().accept(new IResourceDeltaVisitor() {
               public boolean visit(IResourceDelta delta) throws CoreException {
               	IResource resource = delta.getResource();
               	if (resource.getType()==IResource.PROJECT) {
               		IProject project = (IProject)resource;
					if (!project.isAccessible()) {
						return false; // i.e., closed project
					}
					if (SVNWorkspaceRoot.isManagedBySubclipse(project)) {
						flushCache = true;
					}
					return false; // No need to check deeper than project.
               	}
                   return true;
               }
           });			
    } catch (CoreException e) {
      SVNProviderPlugin.log(e.getStatus());
    }
	if (flushCache) {
		statusCache.flushPendingStatuses();
	}
}
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
public void onNotify(File path, SVNNodeKind kind) {
	IPath pathEclipse = new Path(path.getAbsolutePath());
	IResource[] resources = SVNWorkspaceRoot.getResourcesFor(pathEclipse, false);
	for (IResource resource : resources) {			
		localRefreshList.add(resource);
	}
       
	if (operationNotifyListener != null)
	{
		operationNotifyListener.onNotify(path, kind);
		if ((operationNotifyListener.getMonitor() != null) && (operationNotifyListener.getMonitor().isCanceled()))
		{
			try {
				svnClient.cancelOperation();
			} catch (SVNClientException e) {
				SVNProviderPlugin.log(SVNException.wrapException(e));
			}
		}
	}
}
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
private static ISVNLocalResource getSvnResource(String path) {
  	IResource resource = null;
  	ISVNLocalResource svnResource = null;
  	if (path != null) {
   	File file = new File(path);
	if (file.exists()) {
		if (file.isDirectory()) {
			resource = ResourcesPlugin.getWorkspace().getRoot().getContainerForLocation(new Path(path));
		}
		else {
			resource = ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(new Path(path));
		}
		if (resource != null) {
			svnResource = SVNWorkspaceRoot.getSVNResourceFor(resource);
		}
	}
  	}
return svnResource;
  }
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
/**
   * @return true if the container is managed by SVN
   */
  public boolean isManagedBySubversion(IPath folder)
  {
  	File svnDir = folder.append(getAdminDirectoryName()).toFile();
if (svnDir == null || !svnDir.exists() || !svnDir.isDirectory())
	return false;

      try {
      	LocalResourceStatus status = SVNWorkspaceRoot.peekResourceStatusFor(folder);
          if (status.hasRemote())
          	return true;
} catch (SVNException e) {
	if (e.getMessage() != null && e.getMessage().contains(UPGRADE_NEEDED)) {
		return true;				
	}
}

  	return false;
  }
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
public boolean isSupervised(IResource resource) throws TeamException {
try {
	if (resource.isTeamPrivateMember() || SVNWorkspaceRoot.isLinkedResource(resource)) return false;
	RepositoryProvider provider = RepositoryProvider.getProvider(resource.getProject(), SVNProviderPlugin.getTypeId());
	if (provider == null) return false;
	// TODO: what happens for resources that don't exist?
	// TODO: is it proper to use ignored here?
	ISVNLocalResource svnThing = SVNWorkspaceRoot.getSVNResourceFor(resource);
	if (svnThing.isIgnored()) {
		// An ignored resource could have an incoming addition (conflict)
		return (remoteSyncStateStore.getBytes(resource) != null) || 
				((remoteSyncStateStore.members(resource) != null) && (remoteSyncStateStore.members(resource).length > 0));
	}
	return true;
} catch (TeamException e) {
	// If there is no resource in coe this measn there is no local and no remote
	// so the resource is not supervised.
	if (e.getStatus().getCode() == IResourceStatus.RESOURCE_NOT_FOUND) {
		return false;
	}
	throw e;
}
  }
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
public boolean compare(IResource local, IResourceVariant remote) {
	if( local == null && remote == null )
	    return true;
	if( local == null || remote == null )
	    return false;
	ISVNLocalResource a = SVNWorkspaceRoot.getSVNResourceFor(local);
	ISVNRemoteResource b = (ISVNRemoteResource)remote;
	try {
		return a.getStatus().getLastChangedRevision().getNumber() == b.getLastChangedRevision().getNumber();
	} catch (SVNException e) {
           Util.logError("Cannot compare local resource with remote resource",e);
	} catch(NullPointerException npe) {
		// When svn:externals are used several of the above methods can return null
		// We have already checked for the important/expected nulls
		return true;
	}
	return false;
	
}
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
private void autoconnectSVNProject(IProject project, IProgressMonitor monitor) {
     try {
 		PeekStatusCommand command = new PeekStatusCommand(project);
 		try {
	command.execute();
} catch (SVNException e1) {
	if (e1.getMessage() != null && e1.getMessage().contains(SVNProviderPlugin.UPGRADE_NEEDED)) {
		if (!SVNProviderPlugin.handleQuestion("Upgrade Working Copy", project.getName() + " appears to be managed by Subversion, but the working copy needs to be upgraded.  Do you want to upgrade the working copy now?\n\nWarning:  This operation cannot be undone.")) {
			return;			
		}
	}
	 SVNWorkspaceRoot.upgradeWorkingCopy(project, monitor);
}
         SVNWorkspaceRoot.setSharing(project, monitor);
     } catch (TeamException e) {
         SVNProviderPlugin.log(IStatus.ERROR, "Could not auto-share project " + project.getName(), e); //$NON-NLS-1$
     }
 }
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
private boolean promptForAddOfIgnored(IResource[] resources) {
	boolean prompt = false;
	for (int i = 0; i < resources.length; i++) {
		ISVNLocalResource resource = SVNWorkspaceRoot.getSVNResourceFor(resources[i]);
		try {
			if (resource.isIgnored()) {
				prompt = true;
				break;
			} 
		} catch (SVNException e) {
			return false;
		}
	}
	if (prompt) {
		return MessageDialog.openQuestion(getShell(), Policy.bind("AddAction.addIgnoredTitle"), Policy.bind("AddAction.addIgnoredQuestion")); //$NON-NLS-1$ //$NON-NLS-2$
	}
	return true;
}
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
/**
 * Imports a existing SVN Project to the workbench
 * 
 * @param monitor
 *            project monitor
 * @return true if loaded, else false
 * @throws TeamException
 */

boolean importExistingProject(IProgressMonitor monitor)
        throws TeamException {
    if (directory == null) {
        return false;
    }
    try {
        monitor.beginTask("Importing", 3 * 1000);

        createExistingProject(new SubProgressMonitor(monitor, 1000));

        monitor.subTask("Refreshing " + project.getName());
        RepositoryProvider.map(project, SVNProviderPlugin.getTypeId());
        monitor.worked(1000);
        SVNWorkspaceRoot.setSharing(project, new SubProgressMonitor(
                monitor, 1000));

        return true;
    } catch (CoreException ce) {
        throw new SVNException("Failed to import External SVN Project"
                + ce, ce);
    } finally {
        monitor.done();
    }
}
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
/**
 * Retgurn the scheduling rule to be obtained before work
 * begins on the given provider. By default, it is the provider's project.
 * This can be changed by subclasses.
 * @param provider
 * @return
 */
protected ISchedulingRule getSchedulingRule(SVNTeamProvider provider) {
	IResourceRuleFactory ruleFactory = provider.getRuleFactory();
	HashSet rules = new HashSet();
	IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
	for (int i = 0; i < resources.length; i++) {			
		IResource[] pathResources = SVNWorkspaceRoot.getResourcesFor(new Path(resources[i].getLocation().toOSString()), false);
		for (IResource pathResource : pathResources) {
			IProject resourceProject = pathResource.getProject();				
			rules.add(ruleFactory.modifyRule(resourceProject));
			if (resourceProject.getLocation() != null) {
				// Add nested projects
				for (IProject project : projects) {
					if (project.getLocation() != null) {
						if (!project.getLocation().equals(resourceProject.getLocation()) && resourceProject.getLocation().isPrefixOf(project.getLocation())) {
							rules.add(ruleFactory.modifyRule(project));
						}
					}
				}	
			}
		}
	}
	return MultiRule.combine((ISchedulingRule[]) rules.toArray(new ISchedulingRule[rules.size()]));
}
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
protected void execute(IProgressMonitor monitor) throws SVNException, InterruptedException {
	ISVNClientAdapter client = null;
	ISVNRepositoryLocation repository = SVNProviderPlugin.getPlugin().getRepository(fromUrl.toString());
	if (repository != null)
		client = repository.getSVNClient();
	if (client == null)
		client = SVNProviderPlugin.getPlugin().getSVNClientManager().getSVNClient();
	try {
		SVNRevision pegRevision = null;
		if (fromUrl.toString().equals(toUrl.toString()) && localResource != null) {
			if (localResource.getResource() == null) pegRevision = SVNRevision.HEAD;
			else {
				IResource resource = localResource.getResource();
				ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(resource);
				pegRevision = svnResource.getRevision();
			}
		}
		if (pegRevision == null) client.diff(fromUrl, fromRevision, toUrl, toRevision, file, true);
		else client.diff(fromUrl, pegRevision, fromRevision, toRevision, file, true); 
	} catch (SVNClientException e) {
		throw SVNException.wrapException(e);
	} finally {
		monitor.done();
		SVNProviderPlugin.getPlugin().getSVNClientManager().returnSVNClient(client);
	}      
}
 

import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot; //导入依赖的package包/类
protected void execute(SVNTeamProvider provider, IResource[] resources, IProgressMonitor monitor) throws SVNException, InterruptedException {
    try {
        for (int i = 0; i < resources.length; i++) {
            IResource resource = resources[i];
            String pattern = dialog.getIgnorePatternFor(resource);
            ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(resource);
            new AddIgnoredPatternCommand(svnResource.getParent(), pattern).run(monitor);
        }
    } catch (SVNException e) {
    	if (e.operationInterrupted()) {
    		showCancelledMessage();
    	} else {
    		collectStatus(e.getStatus());
    	}
    } finally {
        monitor.done();
    }
}