private void removeFirstRangeFromRemainingRanges(long endRevision, List childrenWithMergeInfo) { for (Iterator children = childrenWithMergeInfo.iterator(); children.hasNext();) { MergePath child = (MergePath) children.next(); if (child == null || child.myIsAbsent) { continue; } if (!child.myRemainingRanges.isEmpty()) { SVNMergeRange[] originalRemainingRanges = child.myRemainingRanges.getRanges(); SVNMergeRange firstRange = originalRemainingRanges[0]; if (firstRange.getEndRevision() == endRevision) { SVNMergeRange[] remainingRanges = new SVNMergeRange[originalRemainingRanges.length - 1]; System.arraycopy(originalRemainingRanges, 1, remainingRanges, 0, originalRemainingRanges.length - 1); child.myRemainingRanges = new SVNMergeRangeList(remainingRanges); } } } }
private SVNMergeRangeList filterNaturalHistoryFromMergeInfo(String srcPath, Map<String, SVNMergeRangeList> implicitMergeInfo, SVNMergeRange requestedRange) { SVNMergeRangeList requestedRangeList = new SVNMergeRangeList(requestedRange.dup()); SVNMergeRangeList filteredRangeList = null; if (implicitMergeInfo != null && requestedRange.getStartRevision() < requestedRange.getEndRevision()) { SVNMergeRangeList impliedRangeList = (SVNMergeRangeList) implicitMergeInfo.get(srcPath); if (impliedRangeList != null) { filteredRangeList = requestedRangeList.diff(impliedRangeList, false); } } if (filteredRangeList == null) { filteredRangeList = requestedRangeList; } return filteredRangeList; }
private String addSourcePathes(SVNMergeInfo mergeInfo) { StringBuffer result = new StringBuffer(); for (Iterator iterator = mergeInfo.getMergeSourcesToMergeLists().entrySet().iterator(); iterator.hasNext();) { Map.Entry entry = (Map.Entry) iterator.next(); String sourcePath = (String) entry.getKey(); SVNMergeRangeList rangeList = (SVNMergeRangeList) entry.getValue(); result.append(sourcePath); result.append(":"); result.append(rangeList.toString()); if (iterator.hasNext()) { result.append('\n'); } } return result.toString(); } }
public static Map intersectMergeInfo(Map mergeInfo1, Map mergeInfo2, boolean considerInheritance) { Map mergeInfo = new TreeMap(); for (Iterator pathsIter = mergeInfo1.keySet().iterator(); pathsIter.hasNext();) { String path = (String) pathsIter.next(); SVNMergeRangeList rangeList1 = (SVNMergeRangeList) mergeInfo1.get(path); SVNMergeRangeList rangeList2 = (SVNMergeRangeList) mergeInfo2.get(path); if (rangeList2 != null) { rangeList2 = rangeList2.intersect(rangeList1, considerInheritance); if (!rangeList2.isEmpty()) { mergeInfo.put(path, rangeList2.dup()); } } } return mergeInfo; }
public static Map<String, SVNMergeRangeList> filterMergeInfoByRanges(Map<String, SVNMergeRangeList> mergeInfo, long youngestRev, long oldestRev) { Map<String, SVNMergeRangeList> filteredMergeInfo = new TreeMap<String, SVNMergeRangeList>(); if (mergeInfo != null) { SVNMergeRange range = new SVNMergeRange(oldestRev, youngestRev, true); SVNMergeRangeList filterRangeList = new SVNMergeRangeList(range); for (Iterator<String> mergeInfoIter = mergeInfo.keySet().iterator(); mergeInfoIter.hasNext();) { String path = mergeInfoIter.next(); SVNMergeRangeList rangeList = mergeInfo.get(path); if (!rangeList.isEmpty()) { SVNMergeRangeList newRangeList = filterRangeList.intersect(rangeList, false); if (!newRangeList.isEmpty()) { filteredMergeInfo.put(path, newRangeList); } } } } return filteredMergeInfo; }
if (rangelist.getSize() > 1) { gap[0] = Math.min(rev1, rev2); gap[1] = rangelist.getRanges()[rangelist.getSize() - 1].getStartRevision(); } else if (implicitSrcMergeInfo.size() > 1) { SVNMergeRangeList implicitMergeRangeList = new SVNMergeRangeList(new SVNMergeRange[0]); SVNMergeRangeList requestedMergeRangeList = new SVNMergeRangeList(Math.min(rev1, rev2), Math.max(rev1, rev2), true); for(Iterator paths = implicitSrcMergeInfo.keySet().iterator(); paths.hasNext();) { String path = (String) paths.next(); rangelist = (SVNMergeRangeList) implicitSrcMergeInfo.get(path); implicitMergeRangeList = implicitMergeRangeList != null ? implicitMergeRangeList.merge(rangelist) : rangelist; SVNMergeRangeList gapRangeList = requestedMergeRangeList.diff(implicitMergeRangeList, false); if (gapRangeList.getSize() > 0) { gap[0] = gapRangeList.getRanges()[0].getStartRevision(); gap[1] = gapRangeList.getRanges()[0].getEndRevision();
long youngestRev = SVNRepository.INVALID_REVISION; SVNMergeRange[] mergeRanges = ranges.getRanges(); for (int i = 0; i < ranges.getSize(); i++) { SVNMergeRange range = mergeRanges[i]; long maxRev = Math.max(range.getStartRevision(), range.getEndRevision()); for (int i = 0; i < ranges.getSize(); i++) { SVNMergeRange range = mergeRanges[i]; long rangeMinRev = Math.min(range.getStartRevision(), range.getEndRevision()) + 1; return SVNMergeRangeList.fromCollection(operativeRanges);
SVNMergeRangeList requestedMergeRangeList = new SVNMergeRangeList(new SVNMergeRange(rev1, rev2, true)); requestedMergeRangeList = requestedMergeRangeList.reverse(); child.myRemainingRanges = targetRangeList.intersect(requestedMergeRangeList, false); child.myRemainingRanges = child.myRemainingRanges.reverse(); } else { child.myRemainingRanges = new SVNMergeRangeList(new SVNMergeRange[0]); SVNMergeRangeList requestedRangeList = new SVNMergeRangeList(new SVNMergeRange(rev1, rev2, true)); child.myRemainingRanges = requestedRangeList.diff(targetRangeList, false); } else { child.myRemainingRanges = new SVNMergeRangeList(new SVNMergeRange(rev1, rev2, true));
public static RevisionRange[] createRevisionRanges(SVNMergeRangeList rangeList) { if (rangeList == null) { return null; } SVNMergeRange[] ranges = rangeList.getRanges(); RevisionRange[] result = new RevisionRange[ranges.length]; for (int i = 0; i < ranges.length; i++) { result[i] = createRevisionRange(ranges[i]); } return result; }
protected void getLogsForMergeInfoRangeList(SVNURL reposRootURL, String[] paths, SVNMergeRangeList rangeList, boolean discoverChangedPaths, String[] revProps, ISVNLogEntryHandler handler) throws SVNException { if (rangeList.isEmpty()) { return; } SVNMergeRange[] listRanges = rangeList.getRanges(); Arrays.sort(listRanges); SVNMergeRange youngestRange = listRanges[listRanges.length - 1]; SVNRevision youngestRev = SVNRevision.create(youngestRange.getEndRevision()); SVNMergeRange oldestRange = listRanges[0]; SVNRevision oldestRev = SVNRevision.create(oldestRange.getStartRevision()); LogHandlerFilter filterHandler = new LogHandlerFilter(handler, rangeList); SVNLogClient16 logClient = getLogClient(); logClient.doLog(reposRootURL, paths, youngestRev, oldestRev, youngestRev, false, discoverChangedPaths, false, 0, revProps, filterHandler); checkCancelled(); }
public static Map getInheritableMergeInfo(Map mergeInfo, String path, long startRev, long endRev) { Map inheritableMergeInfo = new TreeMap(); if (mergeInfo != null) { for (Iterator paths = mergeInfo.keySet().iterator(); paths.hasNext();) { String mergeSrcPath = (String) paths.next(); SVNMergeRangeList rangeList = (SVNMergeRangeList) mergeInfo.get(mergeSrcPath); SVNMergeRangeList inheritableRangeList = null; if (path == null || path.equals(mergeSrcPath)) { inheritableRangeList = rangeList.getInheritableRangeList(startRev, endRev); } else { inheritableRangeList = rangeList.dup(); } if (!inheritableRangeList.isEmpty()) { inheritableMergeInfo.put(mergeSrcPath, inheritableRangeList); } } } return inheritableMergeInfo; }
public void handleLogEntry(SVNLogEntry logEntry) throws SVNException { checkCancelled(); SVNMergeRange range = new SVNMergeRange(logEntry.getRevision() - 1, logEntry.getRevision(), true); SVNMergeRangeList thisRangeList = new SVNMergeRangeList(range); SVNMergeRangeList intersection = thisRangeList.intersect(myRangeList, true); if (intersection == null || intersection.isEmpty()) { return; } SVNErrorManager.assertionFailure(intersection.getSize() == 1, "intersection list size is " + intersection.getSize(), SVNLogType.WC); if (myRealHandler != null) { myRealHandler.handleLogEntry(logEntry); } } }
String mergeSourcePath = (String) mergeInfoIter.next(); SVNMergeRangeList rangeList = (SVNMergeRangeList) mergeInfo[0].get(mergeSourcePath); SVNMergeRange[] ranges = rangeList.getRanges(); for (int i = 0; i < ranges.length; i++) { SVNMergeRange range = ranges[i]; youngerMergeInfo.put(mergeSourcePath, SVNMergeRangeList.fromCollection(youngerRanges)); mergeInfo[0] = SVNMergeInfoUtil.removeMergeInfo(youngerMergeInfo, mergeInfo[0]); break;
MergePath parent = (MergePath) array[parentIndex]; if (isRollback) { child.remainingRanges = child.remainingRanges.reverse(); parent.remainingRanges = parent.remainingRanges.reverse(); SVNMergeRangeList added = child.remainingRanges.diff(parent.remainingRanges, true); SVNMergeRangeList deleted = parent.remainingRanges.diff(child.remainingRanges, true); child.remainingRanges = child.remainingRanges.reverse(); parent.remainingRanges = parent.remainingRanges.reverse(); if (!added.isEmpty() || !deleted.isEmpty()) { String childReposSrcPath = SVNWCUtils.getPathAsChild(targetAbsPath, child.absPath); SVNURL childPrimarySrcUrl = revision1 < revision2 ? url2 : url1;
SVNMergeRangeList beforeMergeRangeList = before.get(source); if (beforeMergeRangeList != null) { SVNMergeRangeList changeRangeList = afterMergeRangeList.diff(beforeMergeRangeList, false); if (!changeRangeList.isEmpty()) { change.put(source, changeRangeList); SVNURL source = entry.getKey(); SVNMergeRangeList mergeRangeList = entry.getValue(); SVNMergeRange[] mergeRanges = mergeRangeList.getRanges(); for (SVNMergeRange mergeRange : mergeRanges) { SVNRevision endRevision = SVNRevision.create(mergeRange.getEndRevision());
lastRange = combineWithLastRange(resultRanges, lastRange, range1, true, false); i++; j++; } else if (res < 0) { lastRange = combineWithLastRange(resultRanges, lastRange, range1, true, false); i++; } else { lastRange = combineWithLastRange(resultRanges, lastRange, range2, true, false); j++; lastRange = combineWithLastRange(resultRanges, lastRange, range, true, false); lastRange = combineWithLastRange(resultRanges, lastRange, range, true, false); return SVNMergeRangeList.fromCollection(resultRanges);
private long getMostInclusiveEndRevision(Map<File, MergePath> childrenWithMergeInfo, boolean isRollBack) { long endRev = SVNRepository.INVALID_REVISION; for (MergePath child : childrenWithMergeInfo.values()) { if (child == null || child.absent) { continue; } if (child.remainingRanges.getSize() > 0) { SVNMergeRange ranges[] = child.remainingRanges.getRanges(); SVNMergeRange range = ranges[0]; if (!SVNRevision.isValidRevisionNumber(endRev) || (isRollBack && range.getEndRevision() > endRev) || (!isRollBack && range.getEndRevision() < endRev)) { endRev = range.getEndRevision(); } } } return endRev; }
SVNMergeRangeList mergeRangesList = SVNMergeRangeList.fromCollection(mergeRanges); mergeRanges = mergeRangesList.getRangesAsList(); if (mergeRanges.isEmpty()) { return mergeRanges;
/** * Creates a new <code>SVNMergeRangeList</code> from a collection of * {@link SVNMergeRange merge ranges}. * * @param mergeRanges merge ranges collection * @return merge range list containing all the ranges from <code>mergeRanges</code> */ public static SVNMergeRangeList fromCollection(Collection mergeRanges) { return new SVNMergeRangeList((SVNMergeRange[]) mergeRanges.toArray(new SVNMergeRange[mergeRanges.size()])); }