public void setAutoDirectoryMapping(String path, String activeVcsName) {
   final List<VirtualFile> defaultRoots = myMappings.getDefaultRoots();
   if (defaultRoots.size() == 1 && StringUtil.isEmpty(myMappings.haveDefaultMapping())) {
     myMappings.removeDirectoryMapping(new VcsDirectoryMapping("", ""));
   }
   myMappings.setMapping(path, activeVcsName);
 }
 public void unregisterVcs(@NotNull AbstractVcs vcs) {
   if (!ApplicationManager.getApplication().isUnitTestMode()
       && myMappings.haveActiveVcs(vcs.getName())) {
     // unlikely
     LOG.warn(
         "Active vcs '" + vcs.getName() + "' is being unregistered. Remove from mappings first.");
   }
   myMappings.beingUnregistered(vcs.getName());
   AllVcses.getInstance(myProject).unregisterManually(vcs);
 }
 @Override
 public void setDirectoryMapping(final String path, final String activeVcsName) {
   if (myMappingsLoaded)
     return; // ignore per-module VCS settings if the mapping table was loaded from .ipr
   myHaveLegacyVcsConfiguration = true;
   myMappings.setMapping(FileUtil.toSystemIndependentName(path), activeVcsName);
 }
 @Override
 public VirtualFile[] getAllVersionedRoots() {
   List<VirtualFile> vFiles = new ArrayList<VirtualFile>();
   final AbstractVcs[] vcses = myMappings.getActiveVcses();
   for (AbstractVcs vcs : vcses) {
     Collections.addAll(vFiles, getRootsUnderVcs(vcs));
   }
   return VfsUtilCore.toVirtualFileArray(vFiles);
 }
 @Override
 @Nullable
 public AbstractVcs getVcsFor(@NotNull VirtualFile file) {
   final String vcsName = myMappings.getVcsFor(file);
   if (vcsName == null || vcsName.isEmpty()) {
     return null;
   }
   return AllVcses.getInstance(myProject).getByName(vcsName);
 }
 @Override
 @Nullable
 public VcsDirectoryMapping getDirectoryMappingFor(final FilePath path) {
   VirtualFile vFile = ChangesUtil.findValidParentAccurately(path);
   if (vFile != null) {
     return myMappings.getMappingFor(vFile);
   }
   return null;
 }
  public void readDirectoryMappings(final Element element) {
    myMappings.clear();

    final List<VcsDirectoryMapping> mappingsList = new ArrayList<VcsDirectoryMapping>();
    boolean haveNonEmptyMappings = false;
    for (Element child : element.getChildren(ELEMENT_MAPPING)) {
      final String vcs = child.getAttributeValue(ATTRIBUTE_VCS);
      if (vcs != null && !vcs.isEmpty()) {
        haveNonEmptyMappings = true;
      }
      VcsDirectoryMapping mapping =
          new VcsDirectoryMapping(child.getAttributeValue(ATTRIBUTE_DIRECTORY), vcs);
      mappingsList.add(mapping);

      Element rootSettingsElement = child.getChild(ELEMENT_ROOT_SETTINGS);
      if (rootSettingsElement != null) {
        String className = rootSettingsElement.getAttributeValue(ATTRIBUTE_CLASS);
        AbstractVcs vcsInstance = findVcsByName(mapping.getVcs());
        if (vcsInstance != null && className != null) {
          final VcsRootSettings rootSettings = vcsInstance.createEmptyVcsRootSettings();
          if (rootSettings != null) {
            try {
              rootSettings.readExternal(rootSettingsElement);
              mapping.setRootSettings(rootSettings);
            } catch (InvalidDataException e) {
              LOG.error(
                  "Failed to load VCS root settings class "
                      + className
                      + " for VCS "
                      + vcsInstance.getClass().getName(),
                  e);
            }
          }
        }
      }
    }
    boolean defaultProject =
        Boolean.TRUE.toString().equals(element.getAttributeValue(ATTRIBUTE_DEFAULT_PROJECT));
    // run autodetection if there's no VCS in default project and
    if (haveNonEmptyMappings || !defaultProject) {
      myMappingsLoaded = true;
    }
    myMappings.setDirectoryMappings(mappingsList);
  }
 @Override
 @Nullable
 public VirtualFile getVcsRootFor(@Nullable final VirtualFile file) {
   final VcsDirectoryMapping mapping = myMappings.getMappingFor(file);
   if (mapping == null) {
     return null;
   }
   final String directory = mapping.getDirectory();
   if (directory.isEmpty()) {
     return myDefaultVcsRootPolicy.getVcsRootFor(file);
   }
   return LocalFileSystem.getInstance().findFileByPath(directory);
 }
  @Override
  public void disposeComponent() {
    releaseEditor();
    myMappings.disposeMe();
    myConnect.disconnect();
    Disposer.dispose(myAnnotationLocalChangesListener);
    myContentManager = null;

    ToolWindowManager toolWindowManager = ToolWindowManager.getInstance(myProject);
    if (toolWindowManager != null && toolWindowManager.getToolWindow(ToolWindowId.VCS) != null) {
      toolWindowManager.unregisterToolWindow(ToolWindowId.VCS);
    }
  }
 @Override
 @NotNull
 public VcsRoot[] getAllVcsRoots() {
   List<VcsRoot> vcsRoots = new ArrayList<VcsRoot>();
   final AbstractVcs[] vcses = myMappings.getActiveVcses();
   for (AbstractVcs vcs : vcses) {
     final VirtualFile[] roots = getRootsUnderVcs(vcs);
     for (VirtualFile root : roots) {
       vcsRoots.add(new VcsRoot(vcs, root));
     }
   }
   return vcsRoots.toArray(new VcsRoot[vcsRoots.size()]);
 }
 @Override
 @Nullable
 public VcsRoot getVcsRootObjectFor(final VirtualFile file) {
   final VcsDirectoryMapping mapping = myMappings.getMappingFor(file);
   if (mapping == null) {
     return null;
   }
   final String directory = mapping.getDirectory();
   final AbstractVcs vcs = findVcsByName(mapping.getVcs());
   if (directory.isEmpty()) {
     return new VcsRoot(vcs, myDefaultVcsRootPolicy.getVcsRootFor(file));
   }
   return new VcsRoot(vcs, LocalFileSystem.getInstance().findFileByPath(directory));
 }
 @Override
 public String haveDefaultMapping() {
   return myMappings.haveDefaultMapping();
 }
 @Override
 public void fireDirectoryMappingsChanged() {
   if (myProject.isOpen() && !myProject.isDisposed()) {
     myMappings.mappingsChanged();
   }
 }
 @Override
 public List<VirtualFile> getRootsUnderVcsWithoutFiltering(final AbstractVcs vcs) {
   return myMappings.getMappingsAsFilesUnderVcs(vcs);
 }
 @Override
 public boolean checkVcsIsActive(final String vcsName) {
   return myMappings.haveActiveVcs(vcsName);
 }
 public void removeDirectoryMapping(VcsDirectoryMapping mapping) {
   myMappings.removeDirectoryMapping(mapping);
 }
 @Override
 public void setDirectoryMappings(final List<VcsDirectoryMapping> items) {
   myHaveLegacyVcsConfiguration = true;
   myMappings.setDirectoryMappings(items);
 }
 @Override
 public boolean hasActiveVcss() {
   return myMappings.hasActiveVcss();
 }
 @Override
 public AbstractVcs[] getAllActiveVcss() {
   return myMappings.getActiveVcses();
 }
 public boolean hasExplicitMapping(final VirtualFile vFile) {
   final VcsDirectoryMapping mapping = myMappings.getMappingFor(vFile);
   return mapping != null && !mapping.isDefaultMapping();
 }
 @Override
 public boolean hasAnyMappings() {
   return !myMappings.isEmpty();
 }
 @Override
 public List<VcsDirectoryMapping> getDirectoryMappings(final AbstractVcs vcs) {
   return myMappings.getDirectoryMappings(vcs.getName());
 }
 @Override
 public List<VcsDirectoryMapping> getDirectoryMappings() {
   return myMappings.getDirectoryMappings();
 }
 public void cleanupMappings() {
   myMappings.cleanupMappings();
 }