import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
private void addChangeToIdx(final Change change, final VcsKey key) {
  final ContentRevision afterRevision = change.getAfterRevision();
  final ContentRevision beforeRevision = change.getBeforeRevision();
  if (afterRevision != null) {
    add(afterRevision.getFile(), change.getFileStatus(), key, beforeRevision == null ? VcsRevisionNumber.NULL : beforeRevision.getRevisionNumber());
  }
  if (beforeRevision != null) {
    if (afterRevision != null) {
      if (! Comparing.equal(beforeRevision.getFile(), afterRevision.getFile())) {
        add(beforeRevision.getFile(), FileStatus.DELETED, key, beforeRevision.getRevisionNumber());
      }
    } else {
      add(beforeRevision.getFile(), change.getFileStatus(), key, beforeRevision.getRevisionNumber());
    }
  }
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
@NotNull
@Override
public Map<VirtualFile, VcsRevisionNumber> getCurrentRevisions(@NotNull Iterable<VirtualFile> files) {
  Map<VirtualFile, VcsRevisionNumber> result = ContainerUtil.newHashMap();
  Map<String, VirtualFile> items = ContainerUtil.newHashMap();
  List<File> ioFiles = ContainerUtil.newArrayList();

  for (VirtualFile file : files) {
    File ioFile = VfsUtilCore.virtualToIoFile(file);
    ioFiles.add(ioFile);
    items.put(ioFile.getAbsolutePath(), file);

    // process in blocks of BATCH_INFO_SIZE size
    if (items.size() == BATCH_INFO_SIZE) {
      collectRevisionsInBatch(result, items, ioFiles);
      items.clear();
      ioFiles.clear();
    }
  }
  // process left files
  collectRevisionsInBatch(result, items, ioFiles);

  return result;
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
public ContentRevision createFileContent(final VcsRevisionNumber revisionNumber, VirtualFile selectedFile) {
  if ((revisionNumber instanceof CvsRevisionNumber)) {
    final CvsConnectionSettings settings = CvsEntriesManager.getInstance().getCvsConnectionSettingsFor(selectedFile.getParent());
    final File file = new File(CvsUtil.getModuleName(selectedFile));
    final CvsRevisionNumber cvsRevisionNumber = ((CvsRevisionNumber)revisionNumber);
    final RevisionOrDate versionInfo;
    if (cvsRevisionNumber.getDateOrRevision() != null) {
      versionInfo = RevisionOrDateImpl.createOn(cvsRevisionNumber.getDateOrRevision());
    }
    else {
      versionInfo = new SimpleRevision(cvsRevisionNumber.asString());
    }

    if (selectedFile.getFileType().isBinary()) {
      return new CvsBinaryContentRevision(file, file, versionInfo, settings, myProject);
    }
    else {
      return new CvsContentRevision(file, file, versionInfo, settings, myProject);
    }

  } else {
    return null;
  }
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
@NotNull
@Override
public ContentRevision createFileContent(@NotNull VcsRevisionNumber revisionNumber, @NotNull VirtualFile selectedFile) {
  FilePath filePath = VcsUtil.getFilePath(selectedFile);
  SVNRevision svnRevision = ((SvnRevisionNumber)revisionNumber).getRevision();

  if (!SVNRevision.HEAD.equals(svnRevision) && revisionNumber.equals(getCurrentRevision(selectedFile))) {
    return SvnContentRevision.createBaseRevision(myVcs, filePath, svnRevision);
  }

  // not clear why we need it, with remote check..
  Status svnStatus = getFileStatus(VfsUtilCore.virtualToIoFile(selectedFile), false);

  return svnStatus != null && svnRevision.equals(svnStatus.getRevision())
         ? SvnContentRevision.createBaseRevision(myVcs, filePath, svnRevision)
         : SvnContentRevision.createRemote(myVcs, filePath, svnRevision);
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
@Override
@Nullable
public ThreeState isRecent(final VirtualFile vf,
                           final VcsKey vcsKey,
                           final VcsRevisionNumber number,
                           final TextRange range,
                           final long boundTime) {
  TreeMap<Integer, Long> treeMap;
  synchronized (myLock) {
    treeMap = myCache.get(new HistoryCacheWithRevisionKey(VcsContextFactory.SERVICE.getInstance().createFilePathOn(vf), vcsKey, number));
  }
  if (treeMap != null) {
    Map.Entry<Integer, Long> last = treeMap.floorEntry(range.getEndOffset());
    if (last == null || last.getKey() < range.getStartOffset()) return ThreeState.NO;
    Map.Entry<Integer, Long> first = treeMap.ceilingEntry(range.getStartOffset());
    assert first != null;
    final SortedMap<Integer,Long> interval = treeMap.subMap(first.getKey(), last.getKey());
    for (Map.Entry<Integer, Long> entry : interval.entrySet()) {
      if (entry.getValue() >= boundTime) return ThreeState.YES;
    }
    return ThreeState.NO;
  }
  return ThreeState.UNSURE;
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
@Override
public void register(final VirtualFile vf, final VcsKey vcsKey, final VcsRevisionNumber number, final FileAnnotation fa) {
  final HistoryCacheWithRevisionKey key = new HistoryCacheWithRevisionKey(VcsContextFactory.SERVICE.getInstance().createFilePathOn(vf), vcsKey, number);
  synchronized (myLock) {
    if (myCache.get(key) != null) return;
  }
  final long absoluteLimit = System.currentTimeMillis() - VcsContentAnnotationSettings.ourAbsoluteLimit;
  final TreeMap<Integer, Long> map = new TreeMap<Integer, Long>();
  final int lineCount = fa.getLineCount();
  for (int i = 0; i < lineCount; i++) {
    Date lineDate = fa.getLineDate(i);
    if (lineDate == null) return;
    if (lineDate.getTime() >= absoluteLimit) map.put(i, lineDate.getTime());
  }
  synchronized (myLock) {
    myCache.put(key, map);
  }
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
public VcsAnnotationLocalChangesListenerImpl(Project project, final ProjectLevelVcsManager vcsManager) {
  myLock = new Object();
  myUpdateStuff = createUpdateStuff();
  myUpdater = new ZipperUpdater(ApplicationManager.getApplication().isUnitTestMode() ? 10 : 300, Alarm.ThreadToUse.POOLED_THREAD, project);
  myConnection = project.getMessageBus().connect();
  myLocalFileSystem = LocalFileSystem.getInstance();
  VcsAnnotationRefresher handler = createHandler();
  myDirtyPaths = new HashSet<String>();
  myDirtyChanges = new HashMap<String, VcsRevisionNumber>();
  myDirtyFiles = new HashSet<VirtualFile>();
  myFileAnnotationMap = MultiMap.createSet();
  myVcsManager = vcsManager;
  myVcsKeySet = new HashSet<VcsKey>();

  myConnection.subscribe(VcsAnnotationRefresher.LOCAL_CHANGES_CHANGED, handler);
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
public static Pair<VcsRevisionNumber, byte[]> getOrLoadCurrentAsBytes(final Project project, FilePath path, @NotNull VcsKey vcsKey,
    final CurrentRevisionProvider loader) throws VcsException, IOException {
  ContentRevisionCache cache = ProjectLevelVcsManager.getInstance(project).getContentRevisionCache();

  VcsRevisionNumber currentRevision;
  Pair<VcsRevisionNumber, byte[]> loaded;
  while (true) {
    currentRevision = putIntoCurrentCache(cache, path, vcsKey, loader);
    final byte[] cachedCurrent = cache.getBytes(path, currentRevision, vcsKey, UniqueType.REPOSITORY_CONTENT);
    if (cachedCurrent != null) {
      return Pair.create(currentRevision, cachedCurrent);
    }
    checkLocalFileSize(path);
    loaded = loader.get();
    if (loaded.getFirst().equals(currentRevision)) break;
  }

  cache.put(path, currentRevision, vcsKey, UniqueType.REPOSITORY_CONTENT, loaded.getSecond());
  return loaded;
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
@Override
public Pair<CommittedChangeList, FilePath> getOneList(VirtualFile file, VcsRevisionNumber number) throws VcsException {
  final ChangeBrowserSettings settings = createDefaultSettings();
  settings.USE_CHANGE_AFTER_FILTER = true;
  settings.USE_CHANGE_BEFORE_FILTER = true;
  settings.CHANGE_AFTER = number.asString();
  settings.CHANGE_BEFORE = number.asString();
  // todo implement in proper way
  VirtualFile localVirtualFile = HgUtil.convertToLocalVirtualFile(file);
  if (localVirtualFile == null) {
    return null;
  }
  final FilePath filePath = VcsUtil.getFilePath(localVirtualFile);
  final CommittedChangeList list = getCommittedChangesForRevision(getLocationFor(filePath), number.asString());
  if (list != null) {
    return new Pair<CommittedChangeList, FilePath>(list, filePath);
  }
  return null;
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
public boolean isChangeLocallyAvailable(final FilePath filePath, @Nullable VcsRevisionNumber localRevision,
                                        VcsRevisionNumber changeRevision, final CvsChangeList changeList) {
  if (localRevision instanceof CvsRevisionNumber && changeRevision instanceof CvsRevisionNumber) {
    final CvsRevisionNumber cvsLocalRevision = (CvsRevisionNumber)localRevision;
    final CvsRevisionNumber cvsChangeRevision = (CvsRevisionNumber)changeRevision;
    final int[] localSubRevisions = cvsLocalRevision.getSubRevisions();
    final int[] changeSubRevisions = cvsChangeRevision.getSubRevisions();
    if (localSubRevisions != null && changeSubRevisions != null) {
      if (localSubRevisions.length != changeSubRevisions.length) {
        // local is trunk, change is branch / vice versa
        return true;
      }
      for(int i=2; i<localSubRevisions.length; i += 2) {
        if (localSubRevisions [i] != changeSubRevisions [i]) {
          // local is one branch, change is a different branch
          return true;
        }
      }
    }
  }

  return isDifferentBranch(filePath, changeList) || (localRevision != null && localRevision.compareTo(changeRevision) >= 0);
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
@Override
public String next() {
  int nextLine;
  while (lineNumberInBounds()) {
    final VcsRevisionNumber vcsRevisionNumber = myAnnotation.originalRevision(myCurrentLine);
    if (myRevisionNumber.equals(vcsRevisionNumber)) {
      nextLine = myCurrentLine;
      final String text = myContentsLines.getLineContents(nextLine);
      if (!StringUtil.isEmptyOrSpaces(text)) {
        ++myCurrentLine;
        return text;
      }
    }
    ++myCurrentLine;
  }
  return null;
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
public PreparedFragmentedContent(final Project project, final FragmentedContent fragmentedContent, final String fileName,
                                 final FileType fileType,
                                 VcsRevisionNumber beforeNumber,
                                 VcsRevisionNumber afterNumber,
                                 FilePath path,
                                 VirtualFile file) {
  myFile = file;
  myProject = project;
  myFragmentedContent = fragmentedContent;
  myFileName = fileName;
  myFileType = fileType;
  myBeforeNumber = beforeNumber;
  myAfterNumber = afterNumber;
  myFilePath = path;
  oldConvertor = new LineNumberConvertor();
  newConvertor = new LineNumberConvertor();
  sbOld = new StringBuilder();
  sbNew = new StringBuilder();
  myBeforeFragments = new ArrayList<TextRange>(fragmentedContent.getSize());
  myAfterFragments = new ArrayList<TextRange>(fragmentedContent.getSize());
  myLineRanges = new ArrayList<BeforeAfter<Integer>>();
  fromFragmentedContent(fragmentedContent);
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
private Runnable createUpdateStuff() {
  return new Runnable() {
    @Override
    public void run() {
      final Set<String> paths = new HashSet<String>();
      final Map<String, VcsRevisionNumber> changes = new HashMap<String, VcsRevisionNumber>();
      final Set<VirtualFile> files = new HashSet<VirtualFile>();
      Set<VcsKey> vcsToRefresh;
      synchronized (myLock) {
        vcsToRefresh = new HashSet<VcsKey>(myVcsKeySet);

        paths.addAll(myDirtyPaths);
        changes.putAll(myDirtyChanges);
        files.addAll(myDirtyFiles);
        myDirtyPaths.clear();
        myDirtyChanges.clear();
        myVcsKeySet.clear();
        myDirtyFiles.clear();
      }

      closeForVcs(vcsToRefresh);
      checkByDirtyScope(paths, changes, files);
    }
  };
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
public AnnotateCurrentRevisionAction(@NotNull FileAnnotation annotation, @NotNull AbstractVcs vcs) {
  super("Annotate Revision", "Annotate selected revision in new tab", AllIcons.Actions.Annotate,
        annotation, vcs);
  List<VcsFileRevision> revisions = annotation.getRevisions();
  if (revisions == null) {
    myRevisions = null;
    return;
  }

  Map<VcsRevisionNumber, VcsFileRevision> map = new HashMap<VcsRevisionNumber, VcsFileRevision>();
  for (VcsFileRevision revision : revisions) {
    map.put(revision.getRevisionNumber(), revision);
  }

  myRevisions = new ArrayList<VcsFileRevision>(annotation.getLineCount());
  for (int i = 0; i < annotation.getLineCount(); i++) {
    myRevisions.add(map.get(annotation.getLineRevisionNumber(i)));
  }
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
public AnnotatePreviousRevisionAction(@NotNull FileAnnotation annotation, @NotNull AbstractVcs vcs) {
  super("Annotate Previous Revision", "Annotate successor of selected revision in new tab", AllIcons.Actions.Annotate,
        annotation, vcs);
  List<VcsFileRevision> revisions = annotation.getRevisions();
  if (revisions == null) {
    myRevisions = null;
    return;
  }

  Map<VcsRevisionNumber, VcsFileRevision> map = new HashMap<VcsRevisionNumber, VcsFileRevision>();
  for (int i = 0; i < revisions.size(); i++) {
    VcsFileRevision revision = revisions.get(i);
    VcsFileRevision previousRevision = i + 1 < revisions.size() ? revisions.get(i + 1) : null;
    map.put(revision.getRevisionNumber(), previousRevision);
  }

  myRevisions = new ArrayList<VcsFileRevision>(annotation.getLineCount());
  for (int i = 0; i < annotation.getLineCount(); i++) {
    myRevisions.add(map.get(annotation.getLineRevisionNumber(i)));
  }
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
@Override
protected void actionPerformed(@NotNull VcsContext vcsContext) {

  final VirtualFile file = vcsContext.getSelectedFiles()[0];
  final Project project = vcsContext.getProject();
  final AbstractVcs vcs = ProjectLevelVcsManager.getInstance(project).getVcsFor(file);
  if (vcs == null) {
    return;
  }
  RevisionSelector selector = vcs.getRevisionSelector();
  final DiffProvider diffProvider = vcs.getDiffProvider();

  if (selector != null) {
    final VcsRevisionNumber vcsRevisionNumber = selector.selectNumber(file);

    if (vcsRevisionNumber != null) {
      DiffActionExecutor.showDiff(diffProvider, vcsRevisionNumber, file, project, VcsBackgroundableActions.COMPARE_WITH);
    }
  }

}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
private void refreshForPath(String path, VcsRevisionNumber number) {
  final File file = new File(path);
  VirtualFile vf = myLocalFileSystem.findFileByIoFile(file);
  if (vf == null) {
    vf = myLocalFileSystem.refreshAndFindFileByIoFile(file);
  }
  if (vf == null) return;
  processFile(number, vf);
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
RemoteRevisionsNumbersCache(final Project project) {
  myProject = project;
  myLock = new Object();
  myData = new HashMap<String, Pair<VcsRoot, VcsRevisionNumber>>();
  myRefreshingQueues = Collections.synchronizedMap(new HashMap<VcsRoot, LazyRefreshingSelfQueue<String>>());
  myLatestRevisionsMap = new HashMap<String, VcsRevisionNumber>();
  myLfs = LocalFileSystem.getInstance();
  myVcsManager = ProjectLevelVcsManager.getInstance(project);
  myVcsConfiguration = VcsConfiguration.getInstance(project);
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
public HgAnnotation(@NotNull Project project, @NotNull HgFile hgFile, @NotNull List<HgAnnotationLine> lines,
                    @NotNull List<HgFileRevision> vcsFileRevisions, VcsRevisionNumber revision) {
  super(project);
  myProject = project;
  myLines = lines;
  myFileRevisions = vcsFileRevisions;
  myFile = hgFile;
  myCurrentRevision = revision;
}
 

import com.intellij.openapi.vcs.history.VcsRevisionNumber; //导入依赖的package包/类
@NotNull
private VcsRevisionNumber getHead() throws VcsException {
  if (myRepository != null) {
    // we force update the GitRepository, because update is asynchronous, and thus the GitChangeProvider may be asked for changes
    // before the GitRepositoryUpdater has captures the current revision change and has updated the GitRepository.
    myRepository.update();
    final String rev = myRepository.getCurrentRevision();
    return rev != null ? new GitRevisionNumber(rev) : VcsRevisionNumber.NULL;
  } else {
    // this may happen on the project startup, when GitChangeProvider may be queried before GitRepository has been initialized.
    LOG.info("GitRepository is null for root " + myVcsRoot);
    return getHeadFromGit();
  }
}