import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
public SvnChangeList(@NotNull final List<CommittedChangeList> lists, @NotNull final SvnRepositoryLocation location) {

    final SvnChangeList sample = (SvnChangeList) lists.get(0);
    myVcs = sample.myVcs;
    myLocation = location;
    setRevision(sample.myRevision);
    myAuthor = sample.myAuthor;
    myDate = sample.myDate;
    myMessage = sample.myMessage;
    myRepositoryRoot = sample.myRepositoryRoot;
    myCommonPathSearcher = new CommonPathSearcher();

    for (CommittedChangeList list : lists) {
      final SvnChangeList svnList = (SvnChangeList) list;
      myChangedPaths.addAll(svnList.myChangedPaths);
      myAddedPaths.addAll(svnList.myAddedPaths);
      myDeletedPaths.addAll(svnList.myDeletedPaths);
      myReplacedPaths.addAll(svnList.myReplacedPaths);
    }
    myKnownAsDirectories = new HashSet<String>(0);
  }
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
@NotNull
@Override
public SelectMergeItemsResult selectMergeItems(List<CommittedChangeList> lists, String mergeTitle, MergeChecker mergeChecker) {
  final ToBeMergedDialog dialog = new ToBeMergedDialog(myProject, lists, mergeTitle, mergeChecker, null);
  dialog.show();
  return new SelectMergeItemsResult() {
    @Override
    public QuickMergeContentsVariants getResultCode() {
      final int code = dialog.getExitCode();
      if (ToBeMergedDialog.MERGE_ALL_CODE == code) {
        return QuickMergeContentsVariants.all;
      }
      return DialogWrapper.OK_EXIT_CODE == code ? QuickMergeContentsVariants.select : QuickMergeContentsVariants.cancel;
    }

    @Override
    public List<CommittedChangeList> getSelectedLists() {
      return dialog.getSelected();
    }
  };
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
@Override
public void loadCommittedChanges(ChangeBrowserSettings changeBrowserSettings,
                                 RepositoryLocation repositoryLocation,
                                 int maxCount,
                                 final AsynchConsumer<CommittedChangeList> consumer) throws VcsException {

  try {
    List<CommittedChangeList> results = getCommittedChanges(changeBrowserSettings, repositoryLocation, maxCount);
    for (CommittedChangeList result : results) {
      consumer.consume(result);
    }
  }
  finally {
    consumer.finished();
  }
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
public CommittedChangeList zip(final RepositoryLocationGroup group, final List<CommittedChangeList> lists) {
  if (lists.size() == 1) {
    return lists.get(0);
  }
  final CommittedChangeList result = lists.get(0);
  for (int i = 1; i < lists.size(); i++) {
    final CommittedChangeList list = lists.get(i);
    for (Change change : list.getChanges()) {
      final Collection<Change> resultChanges = result.getChanges();
      if (! resultChanges.contains(change)) {
        resultChanges.add(change);
      }
    }
  }
  return result;
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
public void loadCommittedChanges(@NotNull ChangeBrowserSettings settings,
                                 @NotNull RepositoryLocation location,
                                 int maxCount,
                                 @NotNull final AsynchConsumer<CommittedChangeList> consumer) throws VcsException {
  try {
    final SvnRepositoryLocation svnLocation = (SvnRepositoryLocation) location;
    final String repositoryRoot = getRepositoryRoot(svnLocation);
    final ChangeBrowserSettings.Filter filter = settings.createFilter();

    getCommittedChangesImpl(settings, svnLocation, maxCount, new Consumer<LogEntry>() {
      public void consume(final LogEntry svnLogEntry) {
        final SvnChangeList cl = new SvnChangeList(myVcs, svnLocation, svnLogEntry, repositoryRoot);
        if (filter.accepts(cl)) {
          consumer.consume(cl);
        }
      }
    }, false, true);
  }
  finally {
    consumer.finished();
  }
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
public void passCachedListsToListener(final VcsConfigurationChangeListener.DetailedNotification notification,
                                      final Project project, final VirtualFile root) {
  final LinkedList<CommittedChangeList> resultList = new LinkedList<CommittedChangeList>();
  myBrowser.reportLoadedLists(new CommittedChangeListsListener() {
    public void onBeforeStartReport() {
    }
    public boolean report(CommittedChangeList list) {
      resultList.add(list);
      return false;
    }
    public void onAfterEndReport() {
      if (! resultList.isEmpty()) {
        notification.execute(project, root, resultList);
      }
    }
  });
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
public void setChangeLists(final List<CommittedChangeList> receivedChanges) {
  final boolean hasEmptyCaches = CommittedChangesCache.getInstance(myProject).hasEmptyCaches();

  ApplicationManager.getApplication().invokeLater(new Runnable() {
    public void run() {
      if (myLoadingChangeListsLabel != null) {
        remove(myLoadingChangeListsLabel);
        myLoadingChangeListsLabel = null;
      }
      myCommittedChangeLists = receivedChanges;
      myTreeBrowser.setItems(myCommittedChangeLists, CommittedChangesBrowserUseCase.UPDATE);
      if (hasEmptyCaches) {
        final StatusText statusText = myTreeBrowser.getEmptyText();
        statusText.clear();
        statusText.appendText("Click ")
          .appendText("Refresh", SimpleTextAttributes.LINK_ATTRIBUTES, new ActionListener() {
            public void actionPerformed(final ActionEvent e) {
              RefreshIncomingChangesAction.doRefresh(myProject);
            }
          })
          .appendText(" to initialize repository changes cache");
      }
    }
  }, myProject.getDisposed());
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
@NotNull
private static List<List<CommittedChangeList>> split(final List<CommittedChangeList> list, final int size) {
  final int listSize = list.size();
  if (listSize < size) {
    return Collections.singletonList(list);
  }
  final int first = listSize % size;

  int start = 0;
  int end = (first == 0) ? (Math.min(listSize, size)) : first;
  final List<List<CommittedChangeList>> result = new ArrayList<List<CommittedChangeList>>(listSize / size + 1);
  while (start < listSize) {
    result.add(list.subList(start, end));
    start = end;
    end += size;
  }
  return result;
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
private List<CommittedChangeList> readChangesInterval(final long indexOffset, final int number) throws IOException {
  openStreams();

  try {
    IndexEntry[] entries = readIndexEntriesByOffset(indexOffset, number);
    if (entries.length == 0) {
      return Collections.emptyList();
    }

    final List<CommittedChangeList> result = new ArrayList<CommittedChangeList>();
    for (IndexEntry entry : entries) {
      final CommittedChangeList changeList = loadChangeListAt(entry.offset);
      result.add(changeList);
    }
    return result;
  } finally {
    closeStreams();
  }
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
public boolean processUpdatedFiles(UpdatedFiles updatedFiles, Collection<CommittedChangeList> receivedChanges) throws IOException {
  boolean haveUnaccountedUpdatedFiles = false;
  openStreams();
  loadHeader();
  ReceivedChangeListTracker tracker = new ReceivedChangeListTracker();
  try {
    final List<IncomingChangeListData> incomingData = loadIncomingChangeListData();
    for(FileGroup group: updatedFiles.getTopLevelGroups()) {
      haveUnaccountedUpdatedFiles |= processGroup(group, incomingData, tracker);
    }
    if (!haveUnaccountedUpdatedFiles) {
      for(IncomingChangeListData data: incomingData) {
        saveIncoming(data, false);
      }
      writeHeader();
    }
  }
  finally {
    closeStreams();
  }
  receivedChanges.addAll(tracker.getChangeLists());
  return haveUnaccountedUpdatedFiles;
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
private void insertPathsChanges(Map<String, Long> paths, CommittedChangeList list, long listId) throws VcsException {
  final PreparedStatement insert = myConnection.getOrCreatePreparedStatement(SqliteTables.PREPARED_INSERT_PATH_2_REVS,
    new ThrowableConvertor<Connection, PreparedStatement, SQLException>() {
      @Override
      public PreparedStatement convert(Connection connection) throws SQLException {
        return connection.prepareStatement("INSERT INTO " + SqliteTables.PATHS_2_REVS.TABLE_NAME +
          " ( " + StringUtil.join(Arrays.asList(SqliteTables.PATHS_2_REVS.PATH_FK, SqliteTables.PATHS_2_REVS.REVISION_FK,
          SqliteTables.PATHS_2_REVS.TYPE, SqliteTables.PATHS_2_REVS.COPY_PATH_ID, SqliteTables.PATHS_2_REVS.DELETE_PATH_ID,
          SqliteTables.PATHS_2_REVS.VISIBLE), " , ") +
          ") VALUES (?,?,?,?,?,?)", Statement.RETURN_GENERATED_KEYS);
      }
    });
  try {
    insert.setLong(2, listId);
    final Collection<Change> withMoved = list.getChangesWithMovedTrees();
    final Set<Change> simple = new HashSet<Change>(list.getChanges());
    for (Change change : withMoved) {
      insertOneChange(paths, insert, change, simple.contains(change));
    }
  }
  catch (SQLException e) {
    throw new VcsException(e);
  }
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
@NotNull
private LogEntryConsumer createLogHandler(final SVNRevision fromIncluding,
                                             final SVNRevision toIncluding,
                                             final boolean includingYoungest,
                                             final boolean includeOldest, final List<CommittedChangeList> result) {
  return new LogEntryConsumer() {
    @Override
    public void consume(LogEntry logEntry) {
      if (myProject.isDisposed()) throw new ProcessCanceledException();
      final ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator();
      if (progress != null) {
        progress.setText2(SvnBundle.message("progress.text2.processing.revision", logEntry.getRevision()));
        progress.checkCanceled();
      }
      if ((!includingYoungest) && (logEntry.getRevision() == fromIncluding.getNumber())) {
        return;
      }
      if ((!includeOldest) && (logEntry.getRevision() == toIncluding.getNumber())) {
        return;
      }
      result.add(new SvnChangeList(myVcs, myLocation, logEntry, myRepositoryRoot.toString()));
    }
  };
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
public void update(final AnActionEvent e) {
  final Project project = CommonDataKeys.PROJECT.getData(e.getDataContext());
  final Presentation presentation = e.getPresentation();

  if (project == null) {
    presentation.setEnabled(false);
    presentation.setVisible(false);
    return;
  }

  presentation.setText(SvnBundle.message("configure.branches.item"));
  presentation.setDescription(SvnBundle.message("configure.branches.item"));
  presentation.setIcon(SvnIcons.ConfigureBranches);

  presentation.setVisible(true);
  
  final ChangeList[] cls = e.getData(VcsDataKeys.CHANGE_LISTS);
  presentation.setEnabled((cls != null) && (cls.length > 0) &&
                          (SvnVcs.getInstance(project).getName().equals(((CommittedChangeList) cls[0]).getVcs().getName())) &&
                          (((SvnChangeList) cls[0]).getRoot() != null));
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
@NotNull
private List<CommittedChangeList> mergeLocationGroupChangeLists(@NotNull RepositoryLocationGroup group) {
  List<CommittedChangeList> result = ContainerUtil.newArrayList();
  List<CommittedChangeList> equalLists = ContainerUtil.newArrayList();
  CommittedChangeList previousList = null;

  for (CommittedChangeList list : Iterables.mergeSorted(collectChangeLists(group.getLocations()), myComparator)) {
    if (previousList != null && myComparator.compare(previousList, list) != 0) {
      result.add(zip(group, equalLists));
      equalLists.clear();
    }
    equalLists.add(list);
    previousList = list;
  }
  if (!equalLists.isEmpty()) {
    result.add(zip(group, equalLists));
  }

  return result;
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
@Override
public void run(ContinuationContext context) {
  QuickMergeInteraction.SelectMergeItemsResult result = myInteraction.selectMergeItems(myChangeLists, myMergeTitle, myMergeChecker);

  switch (result.getResultCode()) {
    case cancel:
      context.cancelEverything();
      break;
    case all:
      context.next(getMergeAllTasks());
      break;
    default:
      List<CommittedChangeList> lists = result.getSelectedLists();

      if (!lists.isEmpty()) {
        runChangeListsMerge(context, lists, myCopyPoint, myMergeTitle);
      }
      break;
  }
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
@Override
public CommittedChangeList zip(final RepositoryLocationGroup group, final List<CommittedChangeList> lists) {
  if (lists.size() == 1) {
    return lists.get(0);
  }
  final CommittedChangeList victim = ReceivedChangeList.unwrap(lists.get(0));
  final ReceivedChangeList result = new ReceivedChangeList(victim);
  result.setForcePartial(false);
  final Set<Change> baseChanges = new HashSet<Change>();

  for (CommittedChangeList list : lists) {
    baseChanges.addAll(ReceivedChangeList.unwrap(list).getChanges());

    final Collection<Change> changes = list.getChanges();
    for (Change change : changes) {
      if (! result.getChanges().contains(change)) {
        result.addChange(change);
      }
    }
  }
  result.setForcePartial(baseChanges.size() != result.getChanges().size());
  return result;
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
public void commitMessageChanged(final AbstractVcs vcs,
                                 final RepositoryLocation location, final long number, final String newMessage) {
  myTaskQueue.run(new Runnable() {
    @Override
    public void run() {
      final ChangesCacheFile file = myCachesHolder.haveCache(location);
      if (file != null) {
        try {
          if (file.isEmpty()) return;
          file.editChangelist(number, newMessage);
          loadIncomingChanges(true);
          fireChangesLoaded(location, Collections.<CommittedChangeList>emptyList());
        }
        catch (IOException e) {
          VcsBalloonProblemNotifier.showOverChangesView(myProject, "Didn't update Repository changes with new message due to error: " + e.getMessage(),
                                                        MessageType.ERROR);
        }
      }
    }
  });
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
public ToBeMergedDialog(final Project project,
                        final List<CommittedChangeList> lists,
                        final String title,
                        final MergeChecker mergeChecker,
                        final PairConsumer<Long, MergeDialogI> moreLoader) {
  super(project, true);
  myMoreLoader = moreLoader;
  myEverythingLoaded = moreLoader == null;
  myStatusMap = Collections.synchronizedMap(new HashMap<Long, ListMergeStatus>());
  myMergeChecker = mergeChecker;
  myAlreadyCalculatedState = moreLoader == null;
  setTitle(title);
  myProject = project;

  // Paging is not used - "Load Xxx" buttons load corresponding new elements and add them to the end of the table. Single (first) page is
  // always used.
  myListsEngine = new BasePageEngine<CommittedChangeList>(lists, lists.size());

  myPanel = new JPanel(new BorderLayout());
  myWiseSelection = new QuantitySelection<Long>(myEverythingLoaded);
  myAlreadyMerged = new HashSet<Change>();
  setOKButtonText("Merge Selected");
  initUI();
  init();
  enableMore();

  myAlarm = new Alarm(Alarm.ThreadToUse.POOLED_THREAD, getDisposable());
  if (! myAlreadyCalculatedState) {
    refreshListStatus(lists);
  }
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
@Nullable
public CommittedChangeList loadRevisions(final VirtualFile vf, final VcsRevisionNumber number) {
  final CommittedChangeList[] list = new CommittedChangeList[1];
  final ThrowableRunnable<VcsException> runnable = new ThrowableRunnable<VcsException>() {
    @Override
    public void run() throws VcsException {
      final Pair<CommittedChangeList, FilePath> pair =
        getCommittedChangesProvider().getOneList(vf, number);
      if (pair != null) {
        list[0] = pair.getFirst();
      }
    }
  };
  return VcsSynchronousProgressWrapper.wrap(runnable, getProject(), "Load revision contents") ? list[0] : null;
}
 

import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList; //导入依赖的package包/类
public Comparator<CommittedChangeList> getComparator() {
  // TODO: CommittedChangeListByDateComparator could be utilized here. But currently it is placed in vcs-impl.
  // TODO: Think of either moving these ChangeListColumn instances to vcs-impl or move comparator to vcs-api.
  return new Comparator<CommittedChangeList>() {
    public int compare(final CommittedChangeList o1, final CommittedChangeList o2) {
      return o1.getCommitDate().compareTo(o2.getCommitDate());
    }
  };
}