import com.intellij.util.containers.Convertor; //导入依赖的package包/类
@Override
public SVNAuthentication requestClientAuthentication(String kind,
                                                     SVNURL url,
                                                     String realm,
                                                     SVNErrorMessage errorMessage,
                                                     SVNAuthentication previousAuth,
                                                     boolean authMayBeStored) {
  authMayBeStored = authMayBeStored && mySaveData;
  Convertor<SVNURL, SVNAuthentication> convertor = myData.get(kind);
  SVNAuthentication result = convertor == null ? null : convertor.convert(url);
  if (result == null) {
    if (ISVNAuthenticationManager.USERNAME.equals(kind)) {
      result = new SVNUserNameAuthentication("username", authMayBeStored);
    } else if (ISVNAuthenticationManager.PASSWORD.equals(kind)) {
      result = new SVNPasswordAuthentication("username", "abc", authMayBeStored, url, false);
    } else if (ISVNAuthenticationManager.SSH.equals(kind)) {
      result = new SVNSSHAuthentication("username", "abc", -1, authMayBeStored, url, false);
    } else if (ISVNAuthenticationManager.SSL.equals(kind)) {
      result = new SVNSSLAuthentication(new File("aaa"), "abc", authMayBeStored, url, false);
    }
  }
  if (! ISVNAuthenticationManager.USERNAME.equals(kind)) {
    myManager.requested(ProviderType.interactive, url, realm, kind, result == null);
  }
  return result;
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
private int importPlaces(final List<BaseInjection> injections) {
  final Map<String, Set<BaseInjection>> map = ContainerUtil.classify(injections.iterator(), new Convertor<BaseInjection, String>() {
    @Override
    public String convert(final BaseInjection o) {
      return o.getSupportId();
    }
  });
  List<BaseInjection> originalInjections = new ArrayList<BaseInjection>();
  List<BaseInjection> newInjections = new ArrayList<BaseInjection>();
  for (String supportId : InjectorUtils.getActiveInjectionSupportIds()) {
    final Set<BaseInjection> importingInjections = map.get(supportId);
    if (importingInjections == null) continue;
    importInjections(getInjections(supportId), importingInjections, originalInjections, newInjections);
  }
  if (!newInjections.isEmpty()) configurationModified();
  replaceInjections(newInjections, originalInjections, true);
  return newInjections.size();
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
public StepIntersection(Convertor<Data, TextRange> dataConvertor,
                        Convertor<Area, TextRange> areasConvertor,
                        final List<Area> areas,
                        Getter<String> debugDocumentTextGetter) {
  myAreas = areas;
  myDebugDocumentTextGetter = debugDocumentTextGetter;
  myAreaIndex = 0;
  myDataConvertor = dataConvertor;
  myAreasConvertor = areasConvertor;
  myHackSearch = new HackSearch<Data, Area, TextRange>(myDataConvertor, myAreasConvertor, new Comparator<TextRange>() {
    @Override
    public int compare(TextRange o1, TextRange o2) {
      return o1.intersects(o2) ? 0 : o1.getStartOffset() < o2.getStartOffset() ? -1 : 1;
    }
  });
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
public HackSearch(Convertor<T, Z> TZConvertor, Convertor<S, Z> SZConvertor, Comparator<Z> zComparator) {
  myTZConvertor = TZConvertor;
  mySZConvertor = SZConvertor;
  myZComparator = zComparator;
  myComparator = new Comparator<S>() {
  @Override
  public int compare(S o1, S o2) {
    Z z1 = mySZConvertor.convert(o1);
    Z z2 = mySZConvertor.convert(o2);
    if (o1 == myFake) {
      z1 = myFakeConverted;
    } else if (o2 == myFake) {
      z2 = myFakeConverted;
    }
    return myZComparator.compare(z1, z2);
  }
};
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
private static Tree createTree(TreeModel treeModel) {
  final Tree tree = new Tree(treeModel);

  tree.setRootVisible(false);
  tree.setShowsRootHandles(true);
  tree.setDragEnabled(false);
  tree.setEditable(false);
  tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);


  final TreeSpeedSearch speedSearch = new TreeSpeedSearch(
    tree,
    new Convertor<TreePath, String>() {
      public String convert(TreePath object) {
        final Object userObject = ((DefaultMutableTreeNode)object.getLastPathComponent()).getUserObject();
        return (userObject instanceof Configuration) ? ((Configuration)userObject).getName() : userObject.toString();
      }
    }
  );
  tree.setCellRenderer(new ExistingTemplatesTreeCellRenderer(speedSearch));

  return tree;
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
@Override
public void run(ContinuationContext context) {
  final Project project = myVcs.getProject();
  final List<FilePatch> patches;
  try {
    patches = IdeaTextPatchBuilder.buildPatch(project, myTheirsChanges, myBaseForPatch.getPath(), false);
    myTextPatches = ObjectsConvertor.convert(patches, new Convertor<FilePatch, TextFilePatch>() {
      @Override
      public TextFilePatch convert(FilePatch o) {
        return (TextFilePatch)o;
      }
    });
  }
  catch (VcsException e) {
    context.handleException(e, true);
  }
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
@Override
protected void installSpeedSearch() {
  new TreeSpeedSearch(this, new Convertor<TreePath, String>() {
    @Override
    public String convert(TreePath path) {
      Object node = path.getLastPathComponent();
      if (node instanceof BreakpointItemNode) {
        return ((BreakpointItemNode)node).getBreakpointItem().speedSearchText();
      }
      else if (node instanceof BreakpointsGroupNode) {
        return ((BreakpointsGroupNode)node).getGroup().getName();
      }
      return "";
    }
  });
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
public List<VirtualFile> getDefaultRoots() {
  synchronized (myLock) {
    final String defaultVcs = haveDefaultMapping();
    if (defaultVcs == null) return Collections.emptyList();
    final List<VirtualFile> list = new ArrayList<VirtualFile>();
    myDefaultVcsRootPolicy.addDefaultVcsRoots(this, defaultVcs, list);
    if (StringUtil.isEmptyOrSpaces(defaultVcs)) {
      return AbstractVcs.filterUniqueRootsDefault(list, Convertor.SELF);
    }
    else {
      final AbstractVcs<?> vcs = AllVcses.getInstance(myProject).getByName(defaultVcs);
      if (vcs == null) {
        return AbstractVcs.filterUniqueRootsDefault(list, Convertor.SELF);
      }
      return vcs.filterUniqueRoots(list, Convertor.SELF);
    }
  }
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
public void init(final Convertor<String, VcsShowConfirmationOption.Value> initOptions) {
  createSettingFor(VcsConfiguration.StandardOption.ADD);
  createSettingFor(VcsConfiguration.StandardOption.REMOVE);
  createSettingFor(VcsConfiguration.StandardOption.CHECKOUT);
  createSettingFor(VcsConfiguration.StandardOption.UPDATE);
  createSettingFor(VcsConfiguration.StandardOption.STATUS);
  createSettingFor(VcsConfiguration.StandardOption.EDIT);

  myConfirmations.put(VcsConfiguration.StandardConfirmation.ADD.getId(), new VcsShowConfirmationOptionImpl(
    VcsConfiguration.StandardConfirmation.ADD.getId(),
    VcsBundle.message("label.text.when.files.created.with.idea", ApplicationNamesInfo.getInstance().getProductName()),
    VcsBundle.message("radio.after.creation.do.not.add"), VcsBundle.message("radio.after.creation.show.options"),
    VcsBundle.message("radio.after.creation.add.silently")));

  myConfirmations.put(VcsConfiguration.StandardConfirmation.REMOVE.getId(), new VcsShowConfirmationOptionImpl(
    VcsConfiguration.StandardConfirmation.REMOVE.getId(),
    VcsBundle.message("label.text.when.files.are.deleted.with.idea", ApplicationNamesInfo.getInstance().getProductName()),
    VcsBundle.message("radio.after.deletion.do.not.remove"), VcsBundle.message("radio.after.deletion.show.options"),
    VcsBundle.message("radio.after.deletion.remove.silently")));

  restoreReadConfirm(VcsConfiguration.StandardConfirmation.ADD, initOptions);
  restoreReadConfirm(VcsConfiguration.StandardConfirmation.REMOVE, initOptions);
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
@SuppressWarnings({"HardCodedStringLiteral"})
public static String formatTextWithLinks(final Project project, final String c, final Convertor<String, String> convertor) {
  if (c == null) return "";
  String comment = XmlTagUtilBase.escapeString(c, false);

  StringBuilder commentBuilder = new StringBuilder();
  IssueNavigationConfiguration config = IssueNavigationConfiguration.getInstance(project);
  final List<IssueNavigationConfiguration.LinkMatch> list = config.findIssueLinks(comment);
  int pos = 0;
  for(IssueNavigationConfiguration.LinkMatch match: list) {
    TextRange range = match.getRange();
    commentBuilder.append(convertor.convert(comment.substring(pos, range.getStartOffset()))).append("<a href=\"").append(match.getTargetUrl()).append("\">");
    commentBuilder.append(range.substring(comment)).append("</a>");
    pos = range.getEndOffset();
  }
  commentBuilder.append(convertor.convert(comment.substring(pos)));
  comment = commentBuilder.toString();

  return comment.replace("\n", "<br>");
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
private void createComponent() {
  setLayout(new BorderLayout());
  myRepositoryTree = new Tree();
  myRepositoryTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
  myRepositoryTree.setRootVisible(false);
  myRepositoryTree.setShowsRootHandles(true);
  JScrollPane scrollPane =
    ScrollPaneFactory.createScrollPane(myRepositoryTree, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
  add(scrollPane, BorderLayout.CENTER);
  myRepositoryTree.setCellRenderer(new SvnRepositoryTreeCellRenderer());
  TreeSpeedSearch search = new TreeSpeedSearch(myRepositoryTree, new Convertor<TreePath, String>() {
    @Override
    public String convert(TreePath o) {
      Object component = o.getLastPathComponent();
      if (component instanceof RepositoryTreeNode) {
        return ((RepositoryTreeNode)component).getURL().toDecodedString();
      }
      return null;
    }
  });
  search.setComparator(new SpeedSearchComparator(false, true));

  EditSourceOnDoubleClickHandler.install(myRepositoryTree);
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
@Override
protected void installSpeedSearch() {
  new TreeSpeedSearch(this, new Convertor<TreePath, String>() {
    @Override
    public String convert(TreePath o) {
      Object object = ((DefaultMutableTreeNode)o.getLastPathComponent()).getUserObject();
      if (object instanceof TemplateGroup) {
        return ((TemplateGroup)object).getName();
      }
      if (object instanceof TemplateImpl) {
        TemplateImpl template = (TemplateImpl)object;
        return StringUtil.notNullize(template.getGroupName()) + " " +
               StringUtil.notNullize(template.getKey()) + " " +
               StringUtil.notNullize(template.getDescription()) + " " +
               template.getTemplateText();
      }
      return "";
    }
  }, true);
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
private <T> SettingsEditor<RunnerAndConfigurationSettings> wrapEditor(SettingsEditor<T> editor,
                                                                      Convertor<RunnerAndConfigurationSettings, T> convertor,
                                                                      ProgramRunner runner) {
  SettingsEditor<RunnerAndConfigurationSettings> wrappedEditor
    = new SettingsEditorWrapper<RunnerAndConfigurationSettings, T>(editor, convertor);

  List<SettingsEditor> unwrappedEditors = myRunner2UnwrappedEditors.get(runner);
  if (unwrappedEditors == null) {
    unwrappedEditors = new ArrayList<SettingsEditor>();
    myRunner2UnwrappedEditors.put(runner, unwrappedEditors);
  }
  unwrappedEditors.add(editor);

  myRunnerEditors.add(wrappedEditor);
  Disposer.register(this, wrappedEditor);

  return wrappedEditor;
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
private void installTree() {
  getTree().getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
  myAutoScrollToSourceHandler.install(getTree());
  myAutoScrollFromSourceHandler.install();

  TreeUtil.installActions(getTree());

  new TreeSpeedSearch(getTree(), new Convertor<TreePath, String>() {
    @Override
    public String convert(final TreePath treePath) {
      final DefaultMutableTreeNode node = (DefaultMutableTreeNode)treePath.getLastPathComponent();
      final Object userObject = node.getUserObject();
      if (userObject != null) {
        return FileStructurePopup.getSpeedSearchText(userObject);
      }
      return null;
    }
  });

  addTreeKeyListener();
  addTreeMouseListeners();
  restoreState();
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
protected void installSpeedSearch() {
  final TreeSpeedSearch treeSpeedSearch = new TreeSpeedSearch(myTree, new Convertor<TreePath, String>() {
    @Override
    @Nullable
    public String convert(TreePath path) {
      final ElementNode lastPathComponent = (ElementNode)path.getLastPathComponent();
      if (lastPathComponent == null) return null;
      String text = lastPathComponent.getDelegate().getText();
      if (text != null) {
        text = convertElementText(text);
      }
      return text;
    }
  });
  treeSpeedSearch.setComparator(getSpeedSearchComparator());
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
@Override
protected void initTree() {
  myTree.getSelectionModel().addTreeSelectionListener(new TreeSelectionListener() {
    @Override
    public void valueChanged(TreeSelectionEvent e) {
      final TreePath path = e.getOldLeadSelectionPath();
      if (path != null) {
        final MyNode node = (MyNode)path.getLastPathComponent();
        final NamedConfigurable namedConfigurable = node.getConfigurable();
        if (namedConfigurable instanceof ScopeConfigurable) {
          ((ScopeConfigurable)namedConfigurable).cancelCurrentProgress();
        }
      }
    }
  });
  super.initTree();
  myTree.setShowsRootHandles(false);
  new TreeSpeedSearch(myTree, new Convertor<TreePath, String>() {
    @Override
    public String convert(final TreePath treePath) {
      return ((MyNode)treePath.getLastPathComponent()).getDisplayName();
    }
  }, true);

  myTree.getEmptyText().setText(IdeBundle.message("scopes.no.scoped"));
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
public DirectoryChooserModuleTreeView(@NotNull Project project) {
  myRootNode = new DefaultMutableTreeNode();
  myTree = new Tree(myRootNode);
  myTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
  myFileIndex = ProjectRootManager.getInstance(project).getFileIndex();
  myProject = project;
  myTree.setRootVisible(false);
  myTree.setShowsRootHandles(true);
  myTree.setCellRenderer(new MyTreeCellRenderer());
  new TreeSpeedSearch(myTree, new Convertor<TreePath, String>() {
    @Override
    public String convert(final TreePath o) {
      final Object userObject = ((DefaultMutableTreeNode)o.getLastPathComponent()).getUserObject();
      if (userObject instanceof Module) {
        return ((Module)userObject).getName();
      }
      else {
        if (userObject == null) return "";
        return userObject.toString();
      }
    }
  }, true);
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
private Map<String, XmlElementDescriptor> configure(String... files) {
  myFixture.configureByFiles(files);
  XmlTag tag = ((XmlFile)getFile()).getRootTag();
  assertNotNull(tag);
  XmlElementDescriptor descriptor = tag.getDescriptor();
  assertNotNull(descriptor);
  XmlElementDescriptor[] descriptors = descriptor.getElementsDescriptors(tag);
  Map<String, XmlElementDescriptor> map =
    ContainerUtil.newMapFromValues(Arrays.asList(descriptors).iterator(), new Convertor<XmlElementDescriptor, String>() {
      @Override
      public String convert(XmlElementDescriptor o) {
        return o.getName();
      }
    });
  map.put(tag.getName(), tag.getDescriptor());
  return map;
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
public static void installSearch(JTree tree) {
  new TreeSpeedSearch(tree, new Convertor<TreePath, String>() {
    @Override
    public String convert(final TreePath treePath) {
      final Object object = ((DefaultMutableTreeNode)treePath.getLastPathComponent()).getUserObject();
      if (object instanceof Module) {
        return ((Module)object).getName();
      }
      else if (object instanceof PsiFile) {
        return ((PsiFile)object).getName();
      }
      else if (object instanceof VirtualFile) {
        return ((VirtualFile)object).getName();
      }
      else {
        return "";
      }
    }
  });
}
 

import com.intellij.util.containers.Convertor; //导入依赖的package包/类
public GithubSelectForkDialog(@NotNull Project project,
                              @Nullable List<GithubFullPath> forks,
                              @NotNull Convertor<String, ForkInfo> checkFork) {
  super(project);
  myProject = project;
  myCheckFork = checkFork;

  myPanel = new GithubSelectForkPanel();

  if (forks != null) {
    myPanel.setUsers(ContainerUtil.map(forks, new Function<GithubFullPath, String>() {
      @Override
      public String fun(GithubFullPath path) {
        return path.getUser();
      }
    }));
  }

  setTitle("Select Base Fork Repository");
  init();
}