import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
/**
 * Opens an Eclipse project.
 *
 * @param localPath
 *        the local path
 * @param importOptions
 *        the import options
 */
public IProject open(final String localPath, final ImportOptions importOptions) throws CoreException {
    final IProject project = createProject(localPath, importOptions);

    if (!project.isOpen()) {
        project.open(null);
    }

    /* Register with project manager. */
    TFSEclipseClientPlugin.getDefault().getProjectManager().addProject(project, importOptions.getTFSRepository());

    if (RepositoryProvider.getProvider(project, TFSRepositoryProvider.PROVIDER_ID) == null) {
        RepositoryProvider.map(project, TFSRepositoryProvider.PROVIDER_ID);
    }

    return project;
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
private void refreshProject(IProject project, IProgressMonitor monitor)
		throws SVNException {
    if (monitor != null)
    {
    	monitor.beginTask("", 100); //$NON-NLS-1$
    	monitor.subTask(Policy.bind("SVNProvider.Creating_project_1", project.getName()));
    }
	try {
		// Register the project with Team
		RepositoryProvider.map(project, SVNProviderPlugin.getTypeId());
		RepositoryProvider.getProvider(project, SVNProviderPlugin.getTypeId());
	} catch (TeamException e) {
		throw new SVNException("Cannot map the project with svn provider",e);
	} finally {
		if (monitor != null)
		{
			monitor.subTask(" ");
			monitor.done();
		}
	}
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
/**
   * Gets the repository which the local filesystem <code>location</code> belongs to.
   */
  public static ISVNRepositoryLocation getRepositoryFor(IPath location) {
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IProject[] projects = root.getProjects();
for (IProject project : projects) {
	if (project.getLocation().isPrefixOf(location) && SVNWorkspaceRoot.isManagedBySubclipse(project)) {
		try {
			SVNTeamProvider teamProvider = (SVNTeamProvider)RepositoryProvider.getProvider(project, SVNProviderPlugin.getTypeId());
			return teamProvider.getSVNWorkspaceRoot().getRepository();
		} catch (SVNException e) {
			// an exception is thrown when resource	is not managed
			SVNProviderPlugin.log(e);
			return null;
		}
	}
}
return null;
  }
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的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.eclipse.team.core.RepositoryProvider; //导入依赖的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.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
private void refreshProject(IProject project, IProgressMonitor monitor)
		throws SVNException {
    if (monitor != null)
    {
    	monitor.beginTask("", 100); //$NON-NLS-1$
    }
	try {
		// Register the project with Team
		RepositoryProvider.map(project, SVNProviderPlugin.getTypeId());
		RepositoryProvider.getProvider(project, SVNProviderPlugin.getTypeId());
		project.refreshLocal(IResource.DEPTH_INFINITE, monitor);
	} catch (Exception e) {
		throw new SVNException("Cannot map the project with svn provider",e);
	} finally {
		if (monitor != null)
		{
			monitor.done();
		}
	}
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
private Map<ProjectAndRepository, List<IResource>> getCommitProviderMapping(IResource[] resources) {
	ProjectAndRepository mapKey = null;
	Map<ProjectAndRepository, List<IResource>> result = new HashMap<ProjectAndRepository, List<IResource>>();
	for (IResource resource : resources) {
		if (mapKey == null || !svnClient.canCommitAcrossWC()) {
			SVNTeamProvider provider = (SVNTeamProvider) RepositoryProvider.getProvider(resource.getProject(), SVNProviderPlugin.getTypeId());
			mapKey = new ProjectAndRepository(provider, getRootURL(SVNWorkspaceRoot.getSVNResourceFor(resource)));
		}
		List<IResource> list = result.get(mapKey);
		if (list == null) {
			list = new ArrayList<IResource>();
			result.put(mapKey, list);
		}
		list.add(resource);
	}
	return result;
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
	// First, ask the user if they want to include conflicts
	SyncInfoSet syncSet = getSyncInfoSet();
	if (!promptForConflictHandling(getShell(), syncSet)) return;
	// Divide the sync info by project
	final Map projectSyncInfos = getProjectSyncInfoSetMap(syncSet);
	monitor.beginTask(null, projectSyncInfos.size() * 100);
	for (Iterator iter = projectSyncInfos.keySet().iterator(); iter.hasNext(); ) {
		final IProject project = (IProject) iter.next();

		// Pass the scheduling rule to the synchronizer so that sync change events
		// and cache commits to disk are batched
		SVNTeamProvider provider = (SVNTeamProvider)RepositoryProvider.getProvider(project, SVNUIPlugin.PROVIDER_ID);
		if (provider != null) {
			run(provider, (SyncInfoSet)projectSyncInfos.get(project), Policy.subMonitorFor(monitor,100));
		}
	}
	monitor.done();
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
	// First, ask the user if they want to include conflicts
	SyncInfoSet syncSet = getSyncInfoSet();
	if (!promptForConflictHandling(getShell(), syncSet)) return;
	// Divide the sync info by project
	final Map projectSyncInfos = getProjectSyncInfoSetMap(syncSet);
	monitor.beginTask(null, projectSyncInfos.size() * 100);
	for (Iterator iter = projectSyncInfos.keySet().iterator(); iter.hasNext(); ) {
		final IProject project = (IProject) iter.next();

		// Pass the scheduling rule to the synchronizer so that sync change events
		// and cache commits to disk are batched
		SVNTeamProvider provider = (SVNTeamProvider)RepositoryProvider.getProvider(project, SVNUIPlugin.PROVIDER_ID);
		if (provider != null) {
			run(provider, (SyncInfoSet)projectSyncInfos.get(project), Policy.subMonitorFor(monitor,100));
			break;
		}
	}
	monitor.done();
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
public boolean isValidInput(Object object) {
  if(object instanceof IResource) {
    RepositoryProvider provider = RepositoryProvider.getProvider(((IResource) object).getProject());
    return provider instanceof SVNTeamProvider;
  } else if(object instanceof ISVNRemoteResource) {
    return true;
  }

  // TODO
  // } else if(object instanceof CVSFileRevision) {
  // return true;
  // } else if(object instanceof CVSLocalFileRevision) {
  // return true;

  return false;
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
public GpsCvsRepositoryHandler(IProject project, GpsProject parent) throws Exception {
	this.parent = parent;
	CVSTeamProvider provider = (CVSTeamProvider) RepositoryProvider.getProvider(project);
	
	CVSWorkspaceRoot root = provider.getCVSWorkspaceRoot();
	CVSRepositoryLocation location = CVSRepositoryLocation.fromString(root.getRemoteLocation().getLocation(false));
	location.setUserMuteable(true);
	address = location.getLocation(false);
	
	ICVSFolder folder = root.getLocalRoot();
	FolderSyncInfo syncInfo = folder.getFolderSyncInfo();
	
	this.location = syncInfo.getRepository() /*module*/;

	/* CVS import handler does not allow us to import the project under different name */
	parent.setName( folder.getName() /* project name */ );
	
	CVSTag tag = syncInfo.getTag();
	if (tag != null) {
		if (tag.getType() != CVSTag.DATE) {
			this.tag = tag.getName();
		}
	}
	
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
@Override
public boolean isValid(ILaunchConfiguration configuration) {
    final String projectName;
    try {

        projectName = configuration.getAttribute(CODENVY_PROJECT_NAME_ATTRIBUTE_NAME, "");

    } catch (CoreException e) {
        throw new RuntimeException(e);
    }

    if (!isEmpty(projectName)) {

        final IProject project = workspaceRoot.getProject(projectName);
        final boolean isCodenvyProject =
                                         project.exists()
                                             && RepositoryProvider.getProvider(project, CodenvyProvider.PROVIDER_ID) != null;
        setErrorMessage(isCodenvyProject ? null : "Project specified is not a valid Codenvy project");

        return isCodenvyProject;
    }

    setErrorMessage("Project not specified");
    return false;
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
public ProjectShareData resolveProjectShareDataForProjects(List<IProject> projects) {
	ProjectShareData data = new ProjectShareData();
	
	for (IProject project: projects){
		RepositoryProvider provider = RepositoryProvider.getProvider(project);
		if (provider == null) {
			continue;
		}
		data.register(provider, project);
	}
	return data;
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
/**
 * Will try to reconnect team provicers - but only for projects not being
 * shared already!
 * @param monitor 
 * 
 * @param data
 * @param projectsList
 */
public void reconnectToTeamProviders(IProgressMonitor monitor, ProjectShareData data, List<IProject> projectsList) {
	if (data == null) {
		return;
	}
	if (projectsList == null || projectsList.isEmpty()) {
		return;
	}

	for (IProject project : projectsList) {
		if (RepositoryProvider.isShared(project)) {
			/* already shared - so ignore! */
			continue;
		}
		String projectName = project.getName();

		IPath path = project.getFullPath();
		String providerId = data.getProviderId(path);
		if (providerId == null) {
			continue;
		}
		try {
			RepositoryProvider.map(project, providerId);
			progressMessage(monitor, "Reconnected team provider for project: "+projectName);
		} catch (TeamException e) {
			IDEUtil.logError("Was not able to reconnect team provider on project:"+projectName, e);
		}
	}
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
public void register(RepositoryProvider provider, IProject project) {
	if (provider == null) {
		return;
	}
	if (project==null){
		return;
	}
	IPath fullPath = project.getFullPath();
	if (fullPath == null) {
		return;
	}
	map.put(fullPath, provider.getID());

}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
@Override
protected IStatus doRun(final IProgressMonitor progressMonitor) throws Exception {
    RepositoryProvider.unmap(project);

    TFSEclipseClientPlugin.getDefault().getProjectManager().removeProject(project);

    return Status.OK_STATUS;
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
@Override
protected IStatus doRun(final IProgressMonitor progressMonitor) throws Exception {
    TFSEclipseClientPlugin.getDefault().getProjectManager().addProject(project, repository);
    RepositoryProvider.map(project, TFSRepositoryProvider.PROVIDER_ID);

    return Status.OK_STATUS;
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
public static boolean isManagedBySubclipse(IProject project) {
	if (project == null)
		return false;

	synchronized (sharedProjects) {
		if (sharedProjects.contains(project))
			return true;
	}

	return null != RepositoryProvider.getProvider(project, SVNProviderPlugin.getTypeId());
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
/**
 * Set the sharing for a project to enable it to be used with the SVNTeamProvider.
    * This is used when a project has .svn directory but is not shared in Eclipse.
 * An exception is thrown if project does not have a remote directory counterpart
 */
public static void setSharing(IProject project, IProgressMonitor monitor) throws TeamException {

	// Ensure provided info matches that of the project
	LocalResourceStatus status = peekResourceStatusFor(project);

       // this folder needs to be managed but also to have a remote counter-part
       // because we need to know its url
       // we will change this exception !
       if (!status.hasRemote())
           throw new SVNException(new SVNStatus(IStatus.ERROR, Policy.bind("SVNProvider.infoMismatch", project.getName())));//$NON-NLS-1$

       String repositoryURL = null;
       ISVNClientAdapter client = SVNProviderPlugin.getPlugin().getSVNClient();
       try {
           SVNProviderPlugin.disableConsoleLogging();
		ISVNInfo info = client.getInfoFromWorkingCopy(project.getLocation().toFile());
		if (info.getRepository() != null)
			repositoryURL = info.getRepository().toString();
	} catch (SVNClientException e) {
	} finally {
        SVNProviderPlugin.enableConsoleLogging();
           SVNProviderPlugin.getPlugin().getSVNClientManager().returnSVNClient(client);
	}
	if (repositoryURL == null)
		repositoryURL = status.getUrlString();

	// Ensure that the provided location is managed
	SVNProviderPlugin.getPlugin().getRepositories().getRepository(repositoryURL, false);

	// Register the project with Team
	RepositoryProvider.map(project, SVNProviderPlugin.getTypeId());
}
 

import org.eclipse.team.core.RepositoryProvider; //导入依赖的package包/类
/**
 * @return true if the container is managed by SVN
 */
public boolean isManagedBySubversion(IContainer container)
{
	if (container instanceof IProject)
	{
		if (RepositoryProvider.getProvider((IProject)container, getTypeId()) != null)
			return true; // svn handled project
		// Don't return at this point, since the project may not be registered
		// yet with Team.
	}

	return isManagedBySubversion(container.getLocation());
}