org.tmatesoft.svn.core.wc

## Class SVNDiffClient

- java.lang.Object
- - org.tmatesoft.svn.core.wc.SVNBasicClient
  - - org.tmatesoft.svn.core.wc.SVNDiffClient

    public class SVNDiffClient
    extends SVNBasicClient

The SVNDiffClient class provides methods allowing to get differences between versioned items ('diff' operation) as well as ones intended for merging file contents.

Here's a list of the SVNDiffClient's methods matched against corresponing commands of the SVN command line client:

SVNKit | Subversion
doDiff() | 'svn diff'
doDiffStatus() | 'svn diff --summarize'
doMerge() | 'svn merge'
doGetLogXXXMergeInfo() | 'svn mergeinfo'

Since:
  1.2
Version:
  1.3
Author:
  TMate Software Ltd.

### Constructor Summary

Constructors
Constructor and Description
`SVNDiffClient(ISVNAuthenticationManager authManager, ISVNOptions options)` Constructs and initializes an SVNDiffClient object with the specified run-time configuration and authentication drivers.
`SVNDiffClient(ISVNRepositoryPool repositoryPool, ISVNOptions options)` Constructs and initializes an SVNDiffClient object with the specified run-time configuration and repository pool object.

### Method Summary

Methods
`void` `doDiff(java.io.File[] paths, SVNRevision rN, SVNRevision rM, SVNRevision pegRevision, SVNDepth depth, boolean useAncestry, java.io.OutputStream result, java.util.Collection<java.lang.String> changeLists)` Iterates over the passed in `paths` calling `doDiff(File, SVNRevision, SVNRevision, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` for each one in the array.
`void` `doDiff(java.io.File path1, SVNRevision rN, java.io.File path2, SVNRevision rM, boolean recursive, boolean useAncestry, java.io.OutputStream result)` Deprecated. use `doDiff(File, SVNRevision, File, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` instead
`void` `doDiff(java.io.File path1, SVNRevision rN, java.io.File path2, SVNRevision rM, SVNDepth depth, boolean useAncestry, java.io.OutputStream result, java.util.Collection<java.lang.String> changeLists)` Produces diff output which describes the delta between `path1` /`rN` and `path2`/`rM`.
`void` `doDiff(java.io.File path, SVNRevision pegRevision, SVNRevision rN, SVNRevision rM, boolean recursive, boolean useAncestry, java.io.OutputStream result)` Deprecated. use `doDiff(File, SVNRevision, SVNRevision, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` instead
`void` `doDiff(java.io.File path, SVNRevision pegRevision, SVNRevision rN, SVNRevision rM, SVNDepth depth, boolean useAncestry, java.io.OutputStream result, java.util.Collection<java.lang.String> changeLists)` Produces diff output which describes the delta between `path` in peg revision `pegRevision`, as it changed between `rN` and `rM`.
`void` `doDiff(java.io.File path1, SVNRevision rN, SVNURL url2, SVNRevision rM, boolean recursive, boolean useAncestry, java.io.OutputStream result)` Deprecated. use `doDiff(File, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` instead
`void` `doDiff(java.io.File path1, SVNRevision rN, SVNURL url2, SVNRevision rM, SVNDepth depth, boolean useAncestry, java.io.OutputStream result, java.util.Collection<java.lang.String> changeLists)` Produces diff output which describes the delta between `path1` /`rN` and `url2`/`rM`.
`void` `doDiff(SVNURL url1, SVNRevision rN, java.io.File path2, SVNRevision rM, boolean recursive, boolean useAncestry, java.io.OutputStream result)` Deprecated. use `doDiff(SVNURL, SVNRevision, File, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` instead
`void` `doDiff(SVNURL url1, SVNRevision rN, java.io.File path2, SVNRevision rM, SVNDepth depth, boolean useAncestry, java.io.OutputStream result, java.util.Collection<java.lang.String> changeLists)` Produces diff output which describes the delta between `url1`/ `rN` and `path2`/`rM`.
`void` `doDiff(SVNURL url, SVNRevision pegRevision, SVNRevision rN, SVNRevision rM, boolean recursive, boolean useAncestry, java.io.OutputStream result)` Deprecated. use `doDiff(SVNURL, SVNRevision, SVNRevision, SVNRevision, SVNDepth, boolean, OutputStream)` instead
`void` `doDiff(SVNURL url, SVNRevision pegRevision, SVNRevision rN, SVNRevision rM, SVNDepth depth, boolean useAncestry, java.io.OutputStream result)` Produces diff output which describes the delta between `url` in peg revision `pegRevision`, as it changed between `rN` and `rM`.
`void` `doDiff(SVNURL url1, SVNRevision rN, SVNURL url2, SVNRevision rM, boolean recursive, boolean useAncestry, java.io.OutputStream result)` Deprecated. use `doDiff(SVNURL, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, OutputStream)` instead
`void` `doDiff(SVNURL url1, SVNRevision rN, SVNURL url2, SVNRevision rM, SVNDepth depth, boolean useAncestry, java.io.OutputStream result)` Produces diff output which describes the delta between `url1`/ `rN` and `url2`/`rM`.
`void` `doDiffStatus(java.io.File path1, SVNRevision rN, java.io.File path2, SVNRevision rM, boolean recursive, boolean useAncestry, ISVNDiffStatusHandler handler)` Deprecated. use `doDiffStatus(File, SVNRevision, File, SVNRevision, SVNDepth, boolean, ISVNDiffStatusHandler)` instead
`void` `doDiffStatus(java.io.File path1, SVNRevision rN, java.io.File path2, SVNRevision rM, SVNDepth depth, boolean useAncestry, ISVNDiffStatusHandler handler)` Produces a diff summary which lists the changed items between `path1`/`rN` and `path2`/`rM` without creating text deltas.
`void` `doDiffStatus(java.io.File path, SVNRevision rN, SVNRevision rM, SVNRevision pegRevision, SVNDepth depth, boolean useAncestry, ISVNDiffStatusHandler handler)` Produces a diff summary which lists the changed items between `path` in peg revision `pegRevision`, as it changed between `rN` and `rM`.
`void` `doDiffStatus(java.io.File path1, SVNRevision rN, SVNURL url2, SVNRevision rM, boolean recursive, boolean useAncestry, ISVNDiffStatusHandler handler)` Deprecated. use `doDiffStatus(File, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, ISVNDiffStatusHandler)` instead
`void` `doDiffStatus(java.io.File path1, SVNRevision rN, SVNURL url2, SVNRevision rM, SVNDepth depth, boolean useAncestry, ISVNDiffStatusHandler handler)` Produces a diff summary which lists the changed items between `path1`/`rN` and `url2`/`rM` without creating text deltas.
`void` `doDiffStatus(SVNURL url1, SVNRevision rN, java.io.File path2, SVNRevision rM, boolean recursive, boolean useAncestry, ISVNDiffStatusHandler handler)` Deprecated. use `doDiffStatus(SVNURL, SVNRevision, File, SVNRevision, SVNDepth, boolean, ISVNDiffStatusHandler)` instead
`void` `doDiffStatus(SVNURL url1, SVNRevision rN, java.io.File path2, SVNRevision rM, SVNDepth depth, boolean useAncestry, ISVNDiffStatusHandler handler)` Produces a diff summary which lists the changed items between `url1`/`rN` and `path2`/`rM` without creating text deltas.
`void` `doDiffStatus(SVNURL url, SVNRevision rN, SVNRevision rM, SVNRevision pegRevision, SVNDepth depth, boolean useAncestry, ISVNDiffStatusHandler handler)` Produces a diff summary which lists the changed items between `url` in peg revision `pegRevision`, as it changed between `rN` and `rM`.
`void` `doDiffStatus(SVNURL url1, SVNRevision rN, SVNURL url2, SVNRevision rM, boolean recursive, boolean useAncestry, ISVNDiffStatusHandler handler)` Deprecated. use `doDiffStatus(SVNURL, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, ISVNDiffStatusHandler)` instead
`void` `doDiffStatus(SVNURL url1, SVNRevision rN, SVNURL url2, SVNRevision rM, SVNDepth depth, boolean useAncestry, ISVNDiffStatusHandler handler)` Produces a diff summary which lists the changed items between `url1`/`rN` and `url2`/`rM` without creating text deltas.
`void` `doGetLogEligibleMergeInfo(java.io.File path, SVNRevision pegRevision, java.io.File mergeSrcPath, SVNRevision srcPegRevision, boolean discoverChangedPaths, java.lang.String[] revisionProperties, ISVNLogEntryHandler handler)` Drives a log entry `handler` with the revisions eligible for merge from `mergeSrcPath` (as of `srcPegRevision`) into `path` (as of `pegRevision`).
`void` `doGetLogEligibleMergeInfo(java.io.File path, SVNRevision pegRevision, SVNURL mergeSrcURL, SVNRevision srcPegRevision, boolean discoverChangedPaths, java.lang.String[] revisionProperties, ISVNLogEntryHandler handler)` Drives a log entry `handler` with the revisions eligible for merge from `mergeSrcURL` (as of `srcPegRevision`) into `path` (as of `pegRevision`).
`void` `doGetLogEligibleMergeInfo(SVNURL url, SVNRevision pegRevision, java.io.File mergeSrcPath, SVNRevision srcPegRevision, boolean discoverChangedPaths, java.lang.String[] revisionProperties, ISVNLogEntryHandler handler)` Drives a log entry `handler` with the revisions eligible for merge from `mergeSrcPath` (as of `srcPegRevision`) into `url` (as of `pegRevision`).
`void` `doGetLogEligibleMergeInfo(SVNURL url, SVNRevision pegRevision, SVNURL mergeSrcURL, SVNRevision srcPegRevision, boolean discoverChangedPaths, java.lang.String[] revisionProperties, ISVNLogEntryHandler handler)` Drives a log entry `handler` with the revisions eligible for merge from `mergeSrcURL` (as of `srcPegRevision`) into `url` (as of `pegRevision`).
`void` `doGetLogMergedMergeInfo(java.io.File path, SVNRevision pegRevision, java.io.File mergeSrcPath, SVNRevision srcPegRevision, boolean discoverChangedPaths, java.lang.String[] revisionProperties, ISVNLogEntryHandler handler)` Drives a log entry `handler` with the revisions merged from `mergeSrcPath` (as of `srcPegRevision`) into `path` (as of `pegRevision`).
`void` `doGetLogMergedMergeInfo(java.io.File path, SVNRevision pegRevision, SVNURL mergeSrcURL, SVNRevision srcPegRevision, boolean discoverChangedPaths, java.lang.String[] revisionProperties, ISVNLogEntryHandler handler)` Drives a log entry `handler` with the revisions merged from `mergeSrcURL` (as of `srcPegRevision`) into `path` (as of `pegRevision`).
`void` `doGetLogMergedMergeInfo(SVNURL url, SVNRevision pegRevision, java.io.File mergeSrcPath, SVNRevision srcPegRevision, boolean discoverChangedPaths, java.lang.String[] revisionProperties, ISVNLogEntryHandler handler)` Drives a log entry `handler` with the revisions merged from `mergeSrcPath` (as of `srcPegRevision`) into `url` (as of `pegRevision`).
`void` `doGetLogMergedMergeInfo(SVNURL url, SVNRevision pegRevision, SVNURL mergeSrcURL, SVNRevision srcPegRevision, boolean discoverChangedPaths, java.lang.String[] revisionProperties, ISVNLogEntryHandler handler)` Drives a log entry `handler` with the revisions merged from `mergeSrcURL` (as of `srcPegRevision`) into `url` (as of `pegRevision`).
`java.util.Map<SVNURL,SVNMergeRangeList>` `doGetMergedMergeInfo(java.io.File path, SVNRevision pegRevision)` Returns mergeinfo as a `Map` with merge source URLs (as `SVNURL`) mapped to range lists (`SVNMergeRangeList`).
`java.util.Map<SVNURL,SVNMergeRangeList>` `doGetMergedMergeInfo(SVNURL url, SVNRevision pegRevision)` Returns mergeinfo as a `Map` with merge source URLs (as `SVNURL`) mapped to range lists (`SVNMergeRangeList`).
`void` `doMerge(java.io.File path1, SVNRevision pegRevision, java.util.Collection<SVNRevisionRange> rangesToMerge, java.io.File dstPath, SVNDepth depth, boolean useAncestry, boolean force, boolean dryRun, boolean recordOnly)` Merges the changes between `path1` in peg revision `pegRevision`, as it changed between the ranges described in `rangesToMerge`.
`void` `doMerge(java.io.File path1, SVNRevision revision1, java.io.File path2, SVNRevision revision2, java.io.File dstPath, boolean recursive, boolean useAncestry, boolean force, boolean dryRun)` Deprecated. use `doMerge(File, SVNRevision, File, SVNRevision, File, SVNDepth, boolean, boolean, boolean, boolean)` instead
`void` `doMerge(java.io.File path1, SVNRevision revision1, java.io.File path2, SVNRevision revision2, java.io.File dstPath, SVNDepth depth, boolean useAncestry, boolean force, boolean dryRun, boolean recordOnly)` Merges changes from `path1`/`revision1` to `path2`/`revision2` into the working-copy path `dstPath`.
`void` `doMerge(java.io.File path1, SVNRevision pegRevision, SVNRevision revision1, SVNRevision revision2, java.io.File dstPath, boolean recursive, boolean useAncestry, boolean force, boolean dryRun)` Deprecated. use `doMerge(File, SVNRevision, Collection, File, SVNDepth, boolean, boolean, boolean, boolean)` instead
`void` `doMerge(java.io.File path1, SVNRevision revision1, SVNURL url2, SVNRevision revision2, java.io.File dstPath, boolean recursive, boolean useAncestry, boolean force, boolean dryRun)` Deprecated. use `doMerge(File, SVNRevision, SVNURL, SVNRevision, File, SVNDepth, boolean, boolean, boolean, boolean)` instead
`void` `doMerge(java.io.File path1, SVNRevision revision1, SVNURL url2, SVNRevision revision2, java.io.File dstPath, SVNDepth depth, boolean useAncestry, boolean force, boolean dryRun, boolean recordOnly)` Merges changes from `path1`/`revision1` to `url2`/`revision2` into the working-copy path `dstPath`.
`void` `doMerge(SVNURL url1, SVNRevision pegRevision, java.util.Collection<SVNRevisionRange> rangesToMerge, java.io.File dstPath, SVNDepth depth, boolean useAncestry, boolean force, boolean dryRun, boolean recordOnly)` Merges the changes between `url1` in peg revision `pegRevision`, as it changed between the ranges described in `rangesToMerge`.
`void` `doMerge(SVNURL url1, SVNRevision revision1, java.io.File path2, SVNRevision revision2, java.io.File dstPath, boolean recursive, boolean useAncestry, boolean force, boolean dryRun)` Deprecated. use `doMerge(SVNURL, SVNRevision, File, SVNRevision, File, SVNDepth, boolean, boolean, boolean, boolean)` instead
`void` `doMerge(SVNURL url1, SVNRevision revision1, java.io.File path2, SVNRevision revision2, java.io.File dstPath, SVNDepth depth, boolean useAncestry, boolean force, boolean dryRun, boolean recordOnly)` Merges changes from `url1`/`revision1` to `path2`/`revision2` into the working-copy path `dstPath`.
`void` `doMerge(SVNURL url1, SVNRevision pegRevision, SVNRevision revision1, SVNRevision revision2, java.io.File dstPath, boolean recursive, boolean useAncestry, boolean force, boolean dryRun)` Deprecated. use `doMerge(SVNURL, SVNRevision, Collection, File, SVNDepth, boolean, boolean, boolean, boolean)` instead
`void` `doMerge(SVNURL url1, SVNRevision revision1, SVNURL url2, SVNRevision revision2, java.io.File dstPath, boolean recursive, boolean useAncestry, boolean force, boolean dryRun)` Deprecated. use `doMerge(SVNURL, SVNRevision, SVNURL, SVNRevision, File, SVNDepth, boolean, boolean, boolean, boolean)` instead
`void` `doMerge(SVNURL url1, SVNRevision revision1, SVNURL url2, SVNRevision revision2, java.io.File dstPath, SVNDepth depth, boolean useAncestry, boolean force, boolean dryRun, boolean recordOnly)` Merges changes from `url1`/`revision1` to `url2`/`revision2` into the working-copy path `dstPath`.
`void` `doMergeReIntegrate(java.io.File srcPath, SVNRevision pegRevision, java.io.File dstPath, boolean dryRun)` Performs a reintegration merge of `srcPath` at `pegRevision` into `dstPath`.
`void` `doMergeReIntegrate(SVNURL srcURL, SVNRevision pegRevision, java.io.File dstPath, boolean dryRun)` Performs a reintegration merge of `srcURL` at `pegRevision` into `dstPath`.
`void` `doPatch(java.io.File absPatchPath, java.io.File localAbsPath, boolean dryRun, int stripCount)`
`java.util.Collection<SVNURL>` `doSuggestMergeSources(java.io.File path, SVNRevision pegRevision)` Returns a collection of potential merge sources (expressed as full repository `URLs`) for `path` at `pegRevision`.
`java.util.Collection<SVNURL>` `doSuggestMergeSources(SVNURL url, SVNRevision pegRevision)` Returns a collection of potential merge sources (expressed as full repository `URLs`) for `url` at `pegRevision`.
`ISVNDiffGenerator` `getDiffGenerator()` Returns the diff driver being in use.
`SVNDiffOptions` `getMergeOptions()` Gets the diff options that are used in merge operations by this client.
`boolean` `isAllowMixedRevisionsWCForMerge()`
`boolean` `isGitDiffFormat()`
`boolean` `isShowCopiesAsAdds()`
`void` `setAllowMixedRevisionsWCForMerge(boolean allowMixedRevisions)`
`void` `setDiffGenerator(ISVNDiffGenerator diffGenerator)` Sets the specified diff driver for this object to use for generating and writing file differences to an otput stream.
`void` `setGitDiffFormat(boolean gitDiffFormat)`
`void` `setMergeOptions(SVNDiffOptions diffOptions)` Sets diff options for this client to use in merge operations.
`void` `setShowCopiesAsAdds(boolean showCopiesAsAdds)`

### Methods inherited from class org.tmatesoft.svn.core.wc.SVNBasicClient

`dontWC17Support, getDebugLog, getOperationsFactory, getOptions, getPathListHandler, getReposRoot, getReposRoot, isIgnoreExternals, isLeaveConflictsUnresolved, isWC17Supported, setDebugLog, setEventHandler, setEventPathPrefix, setIgnoreExternals, setLeaveConflictsUnresolved, setOptions, setPathListHandler`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### SVNDiffClient

    public SVNDiffClient(ISVNAuthenticationManager authManager,
                 ISVNOptions options)

Constructs and initializes an SVNDiffClient object with the specified run-time configuration and authentication drivers.

If `options` is null, then this SVNDiffClient will be using a default run-time configuration driver which takes client-side settings from the default SVN's run-time configuration area but is not able to change those settings (read more on `ISVNOptions` and `SVNWCUtil`).

If `authManager` is null, then this SVNDiffClient will be using a default authentication and network layers driver (see `SVNWCUtil.createDefaultAuthenticationManager()`) which uses server-side settings and auth storage from the default SVN's run-time configuration area (or system properties if that area is not found).

Parameters:
  `authManager` - an authentication and network layers driver
  `options` - a run-time configuration options driver

#### SVNDiffClient

    public SVNDiffClient(ISVNRepositoryPool repositoryPool,
                 ISVNOptions options)

Constructs and initializes an SVNDiffClient object with the specified run-time configuration and repository pool object.

If `options` is null, then this SVNDiffClient will be using a default run-time configuration driver which takes client-side settings from the default SVN's run-time configuration area but is not able to change those settings (read more on `ISVNOptions` and `SVNWCUtil`).

If `repositoryPool` is null, then `SVNRepositoryFactory` will be used to create `repository access objects`.

Parameters:
  `repositoryPool` - a repository pool object
  `options` - a run-time configuration options driver

### Method Detail

#### setDiffGenerator

    public void setDiffGenerator(ISVNDiffGenerator diffGenerator)

Sets the specified diff driver for this object to use for generating and writing file differences to an otput stream.

If no specific diff driver was set in this way, a default one will be used (see `DefaultSVNDiffGenerator`).

Parameters:
  `diffGenerator` - a diff driver
See Also:
  `getDiffGenerator()`

#### getDiffGenerator

    public ISVNDiffGenerator getDiffGenerator()

Returns the diff driver being in use.

If no specific diff driver was previously provided, a default one will be returned (see `DefaultSVNDiffGenerator`).

Returns:
  the diff driver being in use
See Also:
  `setDiffGenerator(ISVNDiffGenerator)`

#### setMergeOptions

    public void setMergeOptions(SVNDiffOptions diffOptions)

Sets diff options for this client to use in merge operations.

Parameters:
  `diffOptions` - diff options object

#### getMergeOptions

    public SVNDiffOptions getMergeOptions()

Gets the diff options that are used in merge operations by this client. If none was provided by the user, one created as `new SVNDiffOptions()` will be returned and used further.

Returns:
  diff options

#### doDiff

    public void doDiff(SVNURL url,
              SVNRevision pegRevision,
              SVNRevision rN,
              SVNRevision rM,
              boolean recursive,
              boolean useAncestry,
              java.io.OutputStream result)
                throws SVNException

Deprecated. use `doDiff(SVNURL, SVNRevision, SVNRevision, SVNRevision, SVNDepth, boolean, OutputStream)` instead
Generates the differences for the specified URL taken from the two specified revisions and writes the result to the provided output stream.

Corresponds to the SVN command line client's `'svn diff -r N:M URL'` command.

Parameters:
  `url` - a repository location
  `pegRevision` - a revision in which `url` is first looked up
  `rN` - an old revision
  `rM` - a new revision
  `recursive` - true to descend recursively
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
Throws:
  `SVNException` - if one of the following is true:
  - at least one of `rN`, `rM` and `pegRevision` is invalid
  - at least one of `rN` and `rM` is a local revision (see `SVNRevision.isLocal()`)
  - `url` was not found in `rN`
  - `url` was not found in `rM`

#### doDiff

    public void doDiff(SVNURL url,
              SVNRevision pegRevision,
              SVNRevision rN,
              SVNRevision rM,
              SVNDepth depth,
              boolean useAncestry,
              java.io.OutputStream result)
                throws SVNException

Produces diff output which describes the delta between `url` in peg revision `pegRevision`, as it changed between `rN` and `rM`.

If `pegRevision is `invalid`, behaves identically to `doDiff(SVNURL, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, OutputStream)`, using `url` for both of that function's `url1` and `url2` arguments.

All other options are handled identically to `doDiff(SVNURL, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, OutputStream)`.`

Parameters:
  `url` - a repository location
  `pegRevision` - a revision in which `url` is first looked up
  `rN` - an old revision
  `rM` - a new revision
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
Throws:
  `SVNException` - if one of the following is true:
  - exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either of `rN` and `rM` is either `invalid` or `local`
  - exception with `SVNErrorCode.FS_NOT_FOUND` error code - `url` can not be found in either `rN` or `rM`
Since:
  1.2, SVN 1.5

#### doDiff

    public void doDiff(java.io.File path,
              SVNRevision pegRevision,
              SVNRevision rN,
              SVNRevision rM,
              boolean recursive,
              boolean useAncestry,
              java.io.OutputStream result)
                throws SVNException

Deprecated. use `doDiff(File, SVNRevision, SVNRevision, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` instead
Generates the differences for the specified path taken from the two specified revisions and writes the result to the provided output stream.

If `rM` is a local revision (see `SVNRevision.isLocal()` ), then the Working Copy `path` is compared with the corresponding repository file at revision `rN` (that is similar to the SVN command line client's `'svn diff -r N path'` command).

Otherwise if both `rN` and `rM` are non-local, then the repository location of `path` is compared for these revisions (`'svn diff -r N:M URL'`).

Parameters:
  `path` - a Working Copy path
  `pegRevision` - a revision in which the repository location of `path` is first looked up
  `rN` - an old revision
  `rM` - a new revision (or a local one)
  `recursive` - true to descend recursively
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
Throws:
  `SVNException` - if one of the following is true:
  - at least one of `rN`, `rM` and `pegRevision` is invalid
  - both `rN` and `rM` are local revisions
  - `path` was not found in `rN`
  - `path` was not found in `rM`

#### doDiff

    public void doDiff(java.io.File[] paths,
              SVNRevision rN,
              SVNRevision rM,
              SVNRevision pegRevision,
              SVNDepth depth,
              boolean useAncestry,
              java.io.OutputStream result,
              java.util.Collection<java.lang.String> changeLists)
                throws SVNException

Iterates over the passed in `paths` calling `doDiff(File, SVNRevision, SVNRevision, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` for each one in the array.

Parameters:
  `paths` - array of working copy paths
  `rN` - an old revision
  `rM` - a new revision
  `pegRevision` - a revision in which the repository location of `paths` is first looked up
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
  `changeLists` - collection with changelist names
Throws:
  `SVNException`
Since:
  1.2, SVN 1.5

#### doDiff

    public void doDiff(java.io.File path,
              SVNRevision pegRevision,
              SVNRevision rN,
              SVNRevision rM,
              SVNDepth depth,
              boolean useAncestry,
              java.io.OutputStream result,
              java.util.Collection<java.lang.String> changeLists)
                throws SVNException

Produces diff output which describes the delta between `path` in peg revision `pegRevision`, as it changed between `rN` and `rM`.

If `rM` is neither `SVNRevision.BASE`, nor `SVNRevision.WORKING`, nor `SVNRevision.COMMITTED`, and if, on the contrary, `rN` is one of the aforementioned revisions, then a wc-against-url diff is performed; if `rN` also is not one of those revision constants, then a url-against-url diff is performed. Otherwise it's a url-against-wc diff.

If `pegRevision is `invalid`, behaves identically to `doDiff(File, SVNRevision, File, SVNRevision, SVNDepth, boolean, OutputStream, Collection)`, using `path` for both of that function's `path1` and `path2` arguments.

All other options are handled identically to `doDiff(File, SVNRevision, File, SVNRevision, SVNDepth, boolean, OutputStream, Collection)`.`

Parameters:
  `path` - a Working Copy path
  `pegRevision` - a revision in which the repository location of `path` is first looked up
  `rN` - an old revision
  `rM` - a new revision
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
  `changeLists` - collection with changelist names
Throws:
  `SVNException` - if one of the following is true:
  - exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either of `rN` and `rM` is `invalid`; if both `rN` and `rM` are either `SVNRevision.WORKING` or `SVNRevision.BASE`
  - exception with `SVNErrorCode.FS_NOT_FOUND` error code - `path` can not be found in either `rN` or `rM`
Since:
  1.2, SVN 1.5

#### doDiff

    public void doDiff(SVNURL url1,
              SVNRevision rN,
              SVNURL url2,
              SVNRevision rM,
              boolean recursive,
              boolean useAncestry,
              java.io.OutputStream result)
                throws SVNException

Deprecated. use `doDiff(SVNURL, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, OutputStream)` instead
Generates the differences for the specified URLs taken from the two specified revisions and writes the result to the provided output stream.

Corresponds to the SVN command line client's `'svn diff -r N:M URL1 URL2'` command.

Parameters:
  `url1` - the first URL to be compared
  `rN` - a revision of `url1`
  `url2` - the second URL to be compared
  `rM` - a revision of `url2`
  `recursive` - true to descend recursively
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
Throws:
  `SVNException` - if one of the following is true:
  - at least one of `rN` and `rM` is invalid
  - `url1` was not found in `rN`
  - `url2` was not found in `rM`

#### doDiff

    public void doDiff(SVNURL url1,
              SVNRevision rN,
              SVNURL url2,
              SVNRevision rM,
              SVNDepth depth,
              boolean useAncestry,
              java.io.OutputStream result)
                throws SVNException

Produces diff output which describes the delta between `url1`/ `rN` and `url2`/`rM`. Writes the output of the diff to `result`.

If this client object uses `DefaultSVNDiffGenerator` and there was a non-null `base path` provided to it, the original path and modified path will have this base path stripped from the front of the respective paths. If the base path is not null but is not a parent path of the target, an exception with the `SVNErrorCode.BAD_RELATIVE_PATH` error code is thrown.

`url1` and `url2` must both represent the same node kind -- that is, if `url1` is a directory, `url2` must also be, and if `url1` is a file, `url2` must also be.

If `depth` is `SVNDepth.INFINITY`, diffs fully recursively. Else if it is `SVNDepth.IMMEDIATES`, diffs the named paths and their file children (if any), and diffs properties of subdirectories, but does not descend further into the subdirectories. Else if `SVNDepth.FILES`, behaves as if for `SVNDepth.IMMEDIATES` except doesn't diff properties of subdirectories. If `SVNDepth.EMPTY`, diffs exactly the named paths but nothing underneath them.

`useAncestry` controls whether or not items being diffed will be checked for relatedness first. Unrelated items are typically transmitted to the editor as a deletion of one thing and the addition of another, but if this flag is true, unrelated items will be diffed as if they were related.

If `ISVNDiffGenerator.isDiffDeleted()` returns true, then no diff output will be generated on deleted files.

Generated headers are encoded using `ISVNDiffGenerator.getEncoding()`.

Diffs output will not be generated for binary files, unless `ISVNDiffGenerator.isForcedBinaryDiff()` is true, in which case diffs will be shown regardless of the content types.

If this client object uses `DefaultSVNDiffGenerator` then a caller can set `SVNDiffOptions` to it which will be used to pass additional options to the diff processes invoked to compare files.

Parameters:
  `url1` - the first URL to be compared
  `rN` - a revision of `url1`
  `url2` - the second URL to be compared against `path1`
  `rM` - a revision of `url2`
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either `rN` or `rM` is `invalid`
Since:
  1.2, SVN 1.5

#### doDiff

    public void doDiff(java.io.File path1,
              SVNRevision rN,
              SVNURL url2,
              SVNRevision rM,
              boolean recursive,
              boolean useAncestry,
              java.io.OutputStream result)
                throws SVNException

Deprecated. use `doDiff(File, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` instead
Generates the differences comparing the specified URL in a certain revision against either the specified Working Copy path or its repository location URL in the specified revision, and writes the result to the provided output stream.

If `rN` is not a local revision (see `SVNRevision.isLocal()`), then its repository location URL as it is in the revision represented by `rN` is taken for comparison with `url2`.

Corresponds to the SVN command line client's `'svn diff -r N:M PATH URL'` command.

Parameters:
  `path1` - a WC path
  `rN` - a revision of `path1`
  `url2` - a repository location URL that is to be compared against `path1` (or its repository location)
  `rM` - a revision of `url2`
  `recursive` - true to descend recursively
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
Throws:
  `SVNException` - if one of the following is true:
  - at least one of `rN` and `rM` is invalid
  - `path1` is not under version control
  - `path1` has no URL
  - `url2` was not found in `rM`
  - the repository location of `path1` was not found in `rN`

#### doDiff

    public void doDiff(java.io.File path1,
              SVNRevision rN,
              SVNURL url2,
              SVNRevision rM,
              SVNDepth depth,
              boolean useAncestry,
              java.io.OutputStream result,
              java.util.Collection<java.lang.String> changeLists)
                throws SVNException

Produces diff output which describes the delta between `path1` /`rN` and `url2`/`rM`. Writes the output of the diff to `result`.

If this client object uses `DefaultSVNDiffGenerator` and there was a non-null `base path` provided to it, the original path and modified path will have this base path stripped from the front of the respective paths. If the base path is not null but is not a parent path of the target, an exception with the `SVNErrorCode.BAD_RELATIVE_PATH` error code is thrown.

`path1` and `url2` must both represent the same node kind -- that is, if `path1` is a directory, `url2` must also be, and if `path1` is a file, `url2` must also be.

If `depth` is `SVNDepth.INFINITY`, diffs fully recursively. Else if it is `SVNDepth.IMMEDIATES`, diffs the named paths and their file children (if any), and diffs properties of subdirectories, but does not descend further into the subdirectories. Else if `SVNDepth.FILES`, behaves as if for `SVNDepth.IMMEDIATES` except doesn't diff properties of subdirectories. If `SVNDepth.EMPTY`, diffs exactly the named paths but nothing underneath them.

`useAncestry` controls whether or not items being diffed will be checked for relatedness first. Unrelated items are typically transmitted to the editor as a deletion of one thing and the addition of another, but if this flag is true, unrelated items will be diffed as if they were related.

If `ISVNDiffGenerator.isDiffDeleted()` returns true, then no diff output will be generated on deleted files.

Generated headers are encoded using `ISVNDiffGenerator.getEncoding()`.

Diffs output will not be generated for binary files, unless `ISVNDiffGenerator.isForcedBinaryDiff()` is true, in which case diffs will be shown regardless of the content types.

If this client object uses `DefaultSVNDiffGenerator` then a caller can set `SVNDiffOptions` to it which will be used to pass additional options to the diff processes invoked to compare files.

`changeLists` is a collection of `String` changelist names, used as a restrictive filter on items whose differences are reported; that is, doesn't generate diffs about any item unless it's a member of one of those changelists. If `changeLists` is empty (or null), no changelist filtering occurs.

Note: changelist filtering only applies to diffs in which at least one side of the diff represents working copy data.

If both `rN` is either `SVNRevision.WORKING` or `SVNRevision.BASE`, then it will be a wc-against-url; otherwise, a url-against-url diff.

Parameters:
  `path1` - a WC path
  `rN` - a revision of `path1`
  `url2` - a repository location URL that is to be compared against `path1` (or its repository location)
  `rM` - a revision of `url2`
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
  `changeLists` - collection with changelist names
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either `rN` or `rM` is `invalid`
Since:
  1.2, SVN 1.5

#### doDiff

    public void doDiff(SVNURL url1,
              SVNRevision rN,
              java.io.File path2,
              SVNRevision rM,
              boolean recursive,
              boolean useAncestry,
              java.io.OutputStream result)
                throws SVNException

Deprecated. use `doDiff(SVNURL, SVNRevision, File, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` instead
Generates the differences comparing either the specified Working Copy path or its repository location URL in the specified revision against the specified URL in a certain revision, and writes the result to the provided output stream.

If `rM` is not a local revision (see `SVNRevision.isLocal()`), then its repository location URL as it is in the revision represented by `rM` is taken for comparison with `url1`.

Corresponds to the SVN command line client's `'svn diff -r N:M URL PATH'` command.

Parameters:
  `url1` - a repository location URL
  `rN` - a revision of `url1`
  `path2` - a WC path that is to be compared against `url1`
  `rM` - a revision of `path2`
  `recursive` - true to descend recursively
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
Throws:
  `SVNException` - if one of the following is true:
  - at least one of `rN` and `rM` is invalid
  - `path2` is not under version control
  - `path2` has no URL
  - `url1` was not found in `rN`
  - the repository location of `path2` was not found in `rM`

#### doDiff

    public void doDiff(SVNURL url1,
              SVNRevision rN,
              java.io.File path2,
              SVNRevision rM,
              SVNDepth depth,
              boolean useAncestry,
              java.io.OutputStream result,
              java.util.Collection<java.lang.String> changeLists)
                throws SVNException

Produces diff output which describes the delta between `url1`/ `rN` and `path2`/`rM`. Writes the output of the diff to `result`.

If this client object uses `DefaultSVNDiffGenerator` and there was a non-null `base path` provided to it, the original path and modified path will have this base path stripped from the front of the respective paths. If the base path is not null but is not a parent path of the target, an exception with the `SVNErrorCode.BAD_RELATIVE_PATH` error code is thrown.

`url1` and `path2` must both represent the same node kind -- that is, if `url1` is a directory, `path2` must also be, and if `url1` is a file, `path2` must also be.

If `depth` is `SVNDepth.INFINITY`, diffs fully recursively. Else if it is `SVNDepth.IMMEDIATES`, diffs the named paths and their file children (if any), and diffs properties of subdirectories, but does not descend further into the subdirectories. Else if `SVNDepth.FILES`, behaves as if for `SVNDepth.IMMEDIATES` except doesn't diff properties of subdirectories. If `SVNDepth.EMPTY`, diffs exactly the named paths but nothing underneath them.

`useAncestry` controls whether or not items being diffed will be checked for relatedness first. Unrelated items are typically transmitted to the editor as a deletion of one thing and the addition of another, but if this flag is true, unrelated items will be diffed as if they were related.

If `ISVNDiffGenerator.isDiffDeleted()` returns true, then no diff output will be generated on deleted files.

Generated headers are encoded using `ISVNDiffGenerator.getEncoding()`.

Diffs output will not be generated for binary files, unless `ISVNDiffGenerator.isForcedBinaryDiff()` is true, in which case diffs will be shown regardless of the content types.

If this client object uses `DefaultSVNDiffGenerator` then a caller can set `SVNDiffOptions` to it which will be used to pass additional options to the diff processes invoked to compare files.

`changeLists` is a collection of `String` changelist names, used as a restrictive filter on items whose differences are reported; that is, doesn't generate diffs about any item unless it's a member of one of those changelists. If `changeLists` is empty (or null), no changelist filtering occurs.

Note: changelist filtering only applies to diffs in which at least one side of the diff represents working copy data.

If both `rM` is either `SVNRevision.WORKING` or `SVNRevision.BASE`, then it will be a url-against-wc; otherwise, a url-against-url diff.

Parameters:
  `url1` - a repository location URL
  `rN` - a revision of `url1`
  `path2` - a WC path that is to be compared against `url1`
  `rM` - a revision of `path2`
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
  `changeLists` - collection with changelist names
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either `rN` or `rM` is `invalid`
Since:
  1.2, SVN 1.5

#### doDiff

    public void doDiff(java.io.File path1,
              SVNRevision rN,
              java.io.File path2,
              SVNRevision rM,
              boolean recursive,
              boolean useAncestry,
              java.io.OutputStream result)
                throws SVNException

Deprecated. use `doDiff(File, SVNRevision, File, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` instead
Generates the differences comparing either the specified Working Copy paths or their repository location URLs (any combinations are possible) in the specified revisions and writes the result to the provided output stream.

If both `rN` and `rM` are local revisions (see `SVNRevision.isLocal()`), then a Working Copy `path2` is compared against a Working Copy `path1`.

If `rN` is a local revision but `rM` is not, then the repository location URL of `path2` as it is in the revision represented by `rM` is compared against the Working Copy `path1`.

If `rM` is a local revision but `rN` is not, then the Working Copy `path2` is compared against the repository location URL of `path1` as it is in the revision represented by `rN`.

If both `rN` and `rM` are non-local revisions, then the repository location URL of `path2` in revision `rM` is compared against the repository location URL of `path1` in revision `rN`.

Parameters:
  `path1` - a WC path
  `rN` - a revision of `path1`
  `path2` - a WC path that is to be compared against `path1`
  `rM` - a revision of `path2`
  `recursive` - true to descend recursively
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
Throws:
  `SVNException` - if one of the following is true:
  - at least one of `rN` and `rM` is invalid
  - `path1` is not under version control
  - `path1` has no URL
  - `path2` is not under version control
  - `path2` has no URL
  - the repository location of `path1` was not found in `rN`
  - the repository location of `path2` was not found in `rM`
  - both `rN` and `rM` are local, but either `path1` does not equal `path2`, or `rN` is not `SVNRevision.BASE`, or `rM` is not `SVNRevision.WORKING`

#### doDiff

    public void doDiff(java.io.File path1,
              SVNRevision rN,
              java.io.File path2,
              SVNRevision rM,
              SVNDepth depth,
              boolean useAncestry,
              java.io.OutputStream result,
              java.util.Collection<java.lang.String> changeLists)
                throws SVNException

Produces diff output which describes the delta between `path1` /`rN` and `path2`/`rM`. Writes the output of the diff to `result`.

If this client object uses `DefaultSVNDiffGenerator` and there was a non-null `base path` provided to it, the original path and modified path will have this base path stripped from the front of the respective paths. If the base path is not null but is not a parent path of the target, an exception with the `SVNErrorCode.BAD_RELATIVE_PATH` error code is thrown.

`path1` and `path2` must both represent the same node kind -- that is, if `path1` is a directory, `path2` must also be, and if `path1` is a file, `path2` must also be.

If `depth` is `SVNDepth.INFINITY`, diffs fully recursively. Else if it is `SVNDepth.IMMEDIATES`, diffs the named paths and their file children (if any), and diffs properties of subdirectories, but does not descend further into the subdirectories. Else if `SVNDepth.FILES`, behaves as if for `SVNDepth.IMMEDIATES` except doesn't diff properties of subdirectories. If `SVNDepth.EMPTY`, diffs exactly the named paths but nothing underneath them.

`useAncestry` controls whether or not items being diffed will be checked for relatedness first. Unrelated items are typically transmitted to the editor as a deletion of one thing and the addition of another, but if this flag is true, unrelated items will be diffed as if they were related.

If `ISVNDiffGenerator.isDiffDeleted()` returns true, then no diff output will be generated on deleted files.

Generated headers are encoded using `ISVNDiffGenerator.getEncoding()`.

Diffs output will not be generated for binary files, unless `ISVNDiffGenerator.isForcedBinaryDiff()` is true, in which case diffs will be shown regardless of the content types.

If this client object uses `DefaultSVNDiffGenerator` then a caller can set `SVNDiffOptions` to it which will be used to pass additional options to the diff processes invoked to compare files.

`changeLists` is a collection of `String` changelist names, used as a restrictive filter on items whose differences are reported; that is, doesn't generate diffs about any item unless it's a member of one of those changelists. If `changeLists` is empty (or null), no changelist filtering occurs.

Note: changelist filtering only applies to diffs in which at least one side of the diff represents working copy data.

If both `rN` and `rM` are either `SVNRevision.WORKING` or `SVNRevision.BASE`, then it will be a wc-against-wc diff operation, in which case no repository access is needed. If only `rN` or `rM` is, then it will be a wc-against-url or url-against-wc diff correspondingly; if neither - a url-against-url diff.

Parameters:
  `path1` - a WC path
  `rN` - a revision of `path1`
  `path2` - a WC path that is to be compared against `path1`
  `rM` - a revision of `path2`
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `result` - the target `OutputStream` where the differences will be written to
  `changeLists` - collection with changelist names
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either `rN` or `rM` is `invalid`
Since:
  1.2, SVN 1.5

#### doDiffStatus

    public void doDiffStatus(java.io.File path1,
                    SVNRevision rN,
                    java.io.File path2,
                    SVNRevision rM,
                    boolean recursive,
                    boolean useAncestry,
                    ISVNDiffStatusHandler handler)
                      throws SVNException

Deprecated. use `doDiffStatus(File, SVNRevision, File, SVNRevision, SVNDepth, boolean, ISVNDiffStatusHandler)` instead
Diffs one path against another one providing short status-like change information to the provided handler. This method functionality is equivalent to the 'svn diff --summarize' command.

Parameters:
  `path1` - the path of a left-hand item to diff
  `rN` - a revision of `path1`
  `path2` - the path of a right-hand item to diff
  `rM` - a revision of `path2`
  `recursive` - controls whether operation must recurse or not
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `handler` - a diff status handler
Throws:
  `SVNException`
Since:
  1.1, new in Subversion 1.4

#### doDiffStatus

    public void doDiffStatus(java.io.File path,
                    SVNRevision rN,
                    SVNRevision rM,
                    SVNRevision pegRevision,
                    SVNDepth depth,
                    boolean useAncestry,
                    ISVNDiffStatusHandler handler)
                      throws SVNException

Produces a diff summary which lists the changed items between `path` in peg revision `pegRevision`, as it changed between `rN` and `rM`.

If `pegRevision` is `invalid`, behaves identically to `doDiffStatus(File, SVNRevision, File, SVNRevision, SVNDepth, boolean, ISVNDiffStatusHandler)` , using `path` for both of that method's `path1` and `path2` argments.

The method may report false positives if `useAncestry` is false, as described in the documentation for `doDiffStatus(File, SVNRevision, File, SVNRevision, SVNDepth, boolean, ISVNDiffStatusHandler)`.

Calls `handler` for each difference with an `SVNDiffStatus` object describing the difference.

See `doDiff(File, SVNRevision, SVNRevision, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` for a description of the other parameters.

Parameters:
  `path` - working copy path
  `rN` - left-hand revision
  `rM` - right-hand revision
  `pegRevision` - a revision in which the repository location of `path` is first looked up
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `handler` - a diff status handler
Throws:
  `SVNException`
Since:
  1.2, SVN 1.5

#### doDiffStatus

    public void doDiffStatus(java.io.File path1,
                    SVNRevision rN,
                    java.io.File path2,
                    SVNRevision rM,
                    SVNDepth depth,
                    boolean useAncestry,
                    ISVNDiffStatusHandler handler)
                      throws SVNException

Produces a diff summary which lists the changed items between `path1`/`rN` and `path2`/`rM` without creating text deltas.

The function may report false positives if `ignoreAncestry` is false, since a file might have been modified between two revisions, but still have the same contents.

Calls `handler` for each difference with an `SVNDiffStatus` object describing the difference.

See `doDiff(File, SVNRevision, File, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` for a description of the other parameters.

Parameters:
  `path1` - the path of a left-hand item to diff
  `rN` - a revision of `path1`
  `path2` - the path of a right-hand item to diff
  `rM` - a revision of `path2`
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `handler` - a diff status handler
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either `rN` or `rM` is `invalid`
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if either of `rM` or rN is either `SVNRevision.WORKING` or `SVNRevision.BASE`
Since:
  1.2, SVN 1.5

#### doDiffStatus

    public void doDiffStatus(java.io.File path1,
                    SVNRevision rN,
                    SVNURL url2,
                    SVNRevision rM,
                    boolean recursive,
                    boolean useAncestry,
                    ISVNDiffStatusHandler handler)
                      throws SVNException

Deprecated. use `doDiffStatus(File, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, ISVNDiffStatusHandler)` instead
Diffs a path against a url providing short status-like change information to the provided handler. This method functionality is equivalent to the 'svn diff --summarize' command.

Parameters:
  `path1` - the path of a left-hand item to diff
  `rN` - a revision of `path1`
  `url2` - the url of a right-hand item to diff
  `rM` - a revision of `url2`
  `recursive` - controls whether operation must recurse or not
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `handler` - a diff status handler
Throws:
  `SVNException`
Since:
  1.1, new in Subversion 1.4

#### doDiffStatus

    public void doDiffStatus(java.io.File path1,
                    SVNRevision rN,
                    SVNURL url2,
                    SVNRevision rM,
                    SVNDepth depth,
                    boolean useAncestry,
                    ISVNDiffStatusHandler handler)
                      throws SVNException

Produces a diff summary which lists the changed items between `path1`/`rN` and `url2`/`rM` without creating text deltas.

The function may report false positives if `ignoreAncestry` is false, since a file might have been modified between two revisions, but still have the same contents.

Calls `handler` for each difference with an `SVNDiffStatus` object describing the difference.

See `doDiff(File, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` for a description of the other parameters.

Parameters:
  `path1` - the path of a left-hand item to diff
  `rN` - a revision of `path1`
  `url2` - repository url as a right-hand item
  `rM` - a revision of `url2`
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `handler` - a diff status handler
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either `rN` or `rM` is `invalid`
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if either of `rM` or rN is either `SVNRevision.WORKING` or `SVNRevision.BASE`
Since:
  1.2, SVN 1.5

#### doDiffStatus

    public void doDiffStatus(SVNURL url1,
                    SVNRevision rN,
                    java.io.File path2,
                    SVNRevision rM,
                    boolean recursive,
                    boolean useAncestry,
                    ISVNDiffStatusHandler handler)
                      throws SVNException

Deprecated. use `doDiffStatus(SVNURL, SVNRevision, File, SVNRevision, SVNDepth, boolean, ISVNDiffStatusHandler)` instead
Diffs a url against a path providing short status-like change information to the provided handler. This method functionality is equivalent to the 'svn diff --summarize' command.

Parameters:
  `url1` - the url of a left-hand item to diff
  `rN` - a revision of `url1`
  `path2` - the path of a right-hand item to diff
  `rM` - a revision of `path2`
  `recursive` - controls whether operation must recurse or not
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `handler` - a diff status handler
Throws:
  `SVNException`
Since:
  1.1, new in Subversion 1.4

#### doDiffStatus

    public void doDiffStatus(SVNURL url1,
                    SVNRevision rN,
                    java.io.File path2,
                    SVNRevision rM,
                    SVNDepth depth,
                    boolean useAncestry,
                    ISVNDiffStatusHandler handler)
                      throws SVNException

Produces a diff summary which lists the changed items between `url1`/`rN` and `path2`/`rM` without creating text deltas.

The function may report false positives if `ignoreAncestry` is false, since a file might have been modified between two revisions, but still have the same contents.

Calls `handler` for each difference with an `SVNDiffStatus` object describing the difference.

See `doDiff(SVNURL, SVNRevision, File, SVNRevision, SVNDepth, boolean, OutputStream, Collection)` for a description of the other parameters.

Parameters:
  `url1` - repository url as a left-hand item
  `rN` - a revision of `url1`
  `path2` - the path of a right-hand item to diff
  `rM` - a revision of `path2`
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `handler` - a diff status handler
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either `rN` or `rM` is `invalid`
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if either of `rM` or rN is either `SVNRevision.WORKING` or `SVNRevision.BASE`
Since:
  1.2, SVN 1.5

#### doDiffStatus

    public void doDiffStatus(SVNURL url1,
                    SVNRevision rN,
                    SVNURL url2,
                    SVNRevision rM,
                    boolean recursive,
                    boolean useAncestry,
                    ISVNDiffStatusHandler handler)
                      throws SVNException

Deprecated. use `doDiffStatus(SVNURL, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, ISVNDiffStatusHandler)` instead
Diffs one url against another one providing short status-like change information to the provided handler. This method functionality is equivalent to the 'svn diff --summarize' command.

Parameters:
  `url1` - the url of a left-hand item to diff
  `rN` - a revision of `url1`
  `url2` - the url of a right-hand item to diff
  `rM` - a revision of `url2`
  `recursive` - controls whether operation must recurse or not
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `handler` - a diff status handler
Throws:
  `SVNException`
Since:
  1.1, new in Subversion 1.4

#### doDiffStatus

    public void doDiffStatus(SVNURL url,
                    SVNRevision rN,
                    SVNRevision rM,
                    SVNRevision pegRevision,
                    SVNDepth depth,
                    boolean useAncestry,
                    ISVNDiffStatusHandler handler)
                      throws SVNException

Produces a diff summary which lists the changed items between `url` in peg revision `pegRevision`, as it changed between `rN` and `rM`.

If `pegRevision` is `invalid`, behaves identically to `doDiffStatus(SVNURL, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, ISVNDiffStatusHandler)` , using `url` for both of that method's `url1` and `url2` argments.

The method may report false positives if `useAncestry` is false, as described in the documentation for `doDiffStatus(SVNURL, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, ISVNDiffStatusHandler)`.

Calls `handler` for each difference with an `SVNDiffStatus` object describing the difference.

See `doDiff(SVNURL, SVNRevision, SVNRevision, SVNRevision, SVNDepth, boolean, OutputStream)` for a description of the other parameters.

Parameters:
  `url` - repository url
  `rN` - left-hand revision
  `rM` - right-hand revision
  `pegRevision` - a revision in which the repository location of `path` is first looked up
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `handler` - a diff status handler
Throws:
  `SVNException`
Since:
  1.2, SVN 1.5

#### doDiffStatus

    public void doDiffStatus(SVNURL url1,
                    SVNRevision rN,
                    SVNURL url2,
                    SVNRevision rM,
                    SVNDepth depth,
                    boolean useAncestry,
                    ISVNDiffStatusHandler handler)
                      throws SVNException

Produces a diff summary which lists the changed items between `url1`/`rN` and `url2`/`rM` without creating text deltas.

The function may report false positives if `ignoreAncestry` is false, since a file might have been modified between two revisions, but still have the same contents.

Calls `handler` for each difference with an `SVNDiffStatus` object describing the difference.

See `doDiff(SVNURL, SVNRevision, SVNURL, SVNRevision, SVNDepth, boolean, OutputStream)` for a description of the other parameters.

Parameters:
  `url1` - the url of a left-hand item to diff
  `rN` - a revision of `url1`
  `url2` - the url of a right-hand item to diff
  `rM` - a revision of `url2`
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `handler` - a diff status handler
Throws:
  `SVNException`
Since:
  1.2, SVN 1.5

#### doMerge

    public void doMerge(java.io.File path1,
               SVNRevision revision1,
               java.io.File path2,
               SVNRevision revision2,
               java.io.File dstPath,
               boolean recursive,
               boolean useAncestry,
               boolean force,
               boolean dryRun)
                 throws SVNException

Deprecated. use `doMerge(File, SVNRevision, File, SVNRevision, File, SVNDepth, boolean, boolean, boolean, boolean)` instead
Applies the differences between two sources (using Working Copy paths to get corresponding URLs of the sources) to a Working Copy path.

Corresponds to the SVN command line client's `'svn merge sourceWCPATH1@rev1 sourceWCPATH2@rev2 WCPATH'` command.

If you need only to try merging your file(s) without actual merging, you should set `dryRun` to true. Your event handler will be dispatched status type information on the target path(s). If a path can be successfully merged, the status type will be `SVNStatusType.MERGED` for that path.

Parameters:
  `path1` - the first source path
  `revision1` - a revision of `path1`
  `path2` - the second source path which URL is to be compared against the URL of `path1`
  `revision2` - a revision of `path2`
  `dstPath` - the target path to which the result should be applied
  `recursive` - true to descend recursively
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `force` - true to force the operation to run
  `dryRun` - if true then only tries the operation to run (to find out if a file can be merged successfully)
Throws:
  `SVNException` - if one of the following is true:
  - at least one of `revision1` and `revision2` is invalid
  - `path1` has no URL
  - `path2` has no URL
  - the repository location of `path1` was not found in `revision1`
  - the repository location of `path2` was not found in `revision2`
  - `dstPath` is not under version control

#### doMerge

    public void doMerge(java.io.File path1,
               SVNRevision revision1,
               java.io.File path2,
               SVNRevision revision2,
               java.io.File dstPath,
               SVNDepth depth,
               boolean useAncestry,
               boolean force,
               boolean dryRun,
               boolean recordOnly)
                 throws SVNException

Merges changes from `path1`/`revision1` to `path2`/`revision2` into the working-copy path `dstPath`.

`path1` and `path2` must both represent the same node kind - that is, if `path1` is a directory, `path2` must also be, and if `path1` is a file, `path2` must also be.

If `depth` is `SVNDepth.INFINITY`, merges fully recursively. Else if `SVNDepth.IMMEDIATES`, merges changes at most to files that are immediate children of `dstPath` and to directory properties of `dstPath` and its immediate subdirectory children. Else if `SVNDepth.FILES`, merges at most to immediate file children of `dstPath` and to `dstPath` itself. Else if `SVNDepth.EMPTY`, applies changes only to `dstPath` (i.e., directory property changes only).

If `depth` is `SVNDepth.UNKNOWN`, uses the depth of `dstPath`.

Uses `useAncestry` to control whether or not items being diffed will be checked for relatedness first. Unrelated items are typically transmitted to the editor as a deletion of one thing and the addition of another, but if this flag is true, unrelated items will be diffed as if they were related.

If `force` is not set and the merge involves deleting locally modified or unversioned items the operation will fail. If `force` is set such items will be deleted.

`merge options` is used to pass arguments to the merge processes (internal or external).

If the caller's `ISVNEventHandler` is not null, then it will be called once for each merged target.

If `recordOnly` is true, the merge isn't actually performed, but the mergeinfo for the revisions which would've been merged is recorded in the working copy (and must be subsequently committed back to the repository).

If `dryRun` is true, the merge is carried out, and full notification feedback is provided, but the working copy is not modified.

Note: this method requires repository access.

Parameters:
  `path1` - left-hand working copy path
  `revision1` - revision of `path1`
  `path2` - right-hand working copy path
  `revision2` - revision of `path2`
  `dstPath` - target working copy path
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `force` - true to force the operation to run
  `dryRun` - if true then runs merge without any file changes
  `recordOnly` - if true, records only the rusult of merge - mergeinfo data
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either `revision1` or `revision2` is `invalid`
  exception with `SVNErrorCode.ENTRY_MISSING_URL` error code - if failed to retrieve url of either `path1` or `path2`
Since:
  1.2, SVN 1.5

#### doMerge

    public void doMerge(java.io.File path1,
               SVNRevision revision1,
               SVNURL url2,
               SVNRevision revision2,
               java.io.File dstPath,
               boolean recursive,
               boolean useAncestry,
               boolean force,
               boolean dryRun)
                 throws SVNException

Deprecated. use `doMerge(File, SVNRevision, SVNURL, SVNRevision, File, SVNDepth, boolean, boolean, boolean, boolean)` instead
Applies the differences between two sources (a source URL against the repository location URL of a source Working Copy path) to a Working Copy path.

If you need only to try merging your file(s) without actual merging, you should set `dryRun` to true. Your event handler will be dispatched status type information on the target path(s). If a path can be successfully merged, the status type will be `SVNStatusType.MERGED` for that path.

Parameters:
  `path1` - the first source - a WC path
  `revision1` - a revision of `path1`
  `url2` - the second source - a URL that is to be compared against the URL of `path1`
  `revision2` - a revision of `url2`
  `dstPath` - the target path to which the result should be applied
  `recursive` - true to descend recursively
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `force` - true to force the operation to run
  `dryRun` - if true then only tries the operation to run (to find out if a file can be merged successfully)
Throws:
  `SVNException` - if one of the following is true:
  - at least one of `revision1` and `revision2` is invalid
  - `path1` has no URL
  - the repository location of `path1` was not found in `revision1`
  - `url2` was not found in `revision2`
  - `dstPath` is not under version control

#### doMerge

    public void doMerge(java.io.File path1,
               SVNRevision revision1,
               SVNURL url2,
               SVNRevision revision2,
               java.io.File dstPath,
               SVNDepth depth,
               boolean useAncestry,
               boolean force,
               boolean dryRun,
               boolean recordOnly)
                 throws SVNException

Merges changes from `path1`/`revision1` to `url2`/`revision2` into the working-copy path `dstPath`.

`path1` and `url2` must both represent the same node kind - that is, if `path1` is a directory, `url2` must also be, and if `path1` is a file, `url2` must also be.

If `depth` is `SVNDepth.INFINITY`, merges fully recursively. Else if `SVNDepth.IMMEDIATES`, merges changes at most to files that are immediate children of `dstPath` and to directory properties of `dstPath` and its immediate subdirectory children. Else if `SVNDepth.FILES`, merges at most to immediate file children of `dstPath` and to `dstPath` itself. Else if `SVNDepth.EMPTY`, applies changes only to `dstPath` (i.e., directory property changes only).

If `depth` is `SVNDepth.UNKNOWN`, uses the depth of `dstPath`.

Uses `useAncestry` to control whether or not items being diffed will be checked for relatedness first. Unrelated items are typically transmitted to the editor as a deletion of one thing and the addition of another, but if this flag is true, unrelated items will be diffed as if they were related.

If `force` is not set and the merge involves deleting locally modified or unversioned items the operation will fail. If `force` is set such items will be deleted.

`merge options` is used to pass arguments to the merge processes (internal or external).

If the caller's `ISVNEventHandler` is not null, then it will be called once for each merged target.

If `recordOnly` is true, the merge isn't actually performed, but the mergeinfo for the revisions which would've been merged is recorded in the working copy (and must be subsequently committed back to the repository).

If `dryRun` is true, the merge is carried out, and full notification feedback is provided, but the working copy is not modified.

Note: this method requires repository access.

Parameters:
  `path1` - left-hand item - working copy path
  `revision1` - revision of `path1`
  `url2` - right-hand item - repository url
  `revision2` - revision of `url2`
  `dstPath` - target working copy path
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `force` - true to force the operation to run
  `dryRun` - if true then runs merge without any file changes
  `recordOnly` - if true, records only the rusult of merge - mergeinfo data
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either `revision1` or `revision2` is `invalid`
  exception with `SVNErrorCode.ENTRY_MISSING_URL` error code - if failed to retrieve the repository url of `path1`
Since:
  1.2, SVN 1.5

#### doMerge

    public void doMerge(SVNURL url1,
               SVNRevision revision1,
               java.io.File path2,
               SVNRevision revision2,
               java.io.File dstPath,
               boolean recursive,
               boolean useAncestry,
               boolean force,
               boolean dryRun)
                 throws SVNException

Deprecated. use `doMerge(SVNURL, SVNRevision, File, SVNRevision, File, SVNDepth, boolean, boolean, boolean, boolean)` instead
Applies the differences between two sources (the repository location URL of a source Working Copy against a source URL) to a Working Copy path.

If you need only to try merging your file(s) without actual merging, you should set `dryRun` to true. Your event handler will be dispatched status type information on the target path(s). If a path can be successfully merged, the status type will be `SVNStatusType.MERGED` for that path.

Parameters:
  `url1` - the first source - a URL
  `revision1` - a revision of `url1`
  `path2` - the second source - a WC path that is to be compared against `url1`
  `revision2` - a revision of `path2`
  `dstPath` - the target path to which the result should be applied
  `recursive` - true to descend recursively
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `force` - true to force the operation to run
  `dryRun` - if true then only tries the operation to run (to find out if a file can be merged successfully)
Throws:
  `SVNException` - if one of the following is true:
  - at least one of `revision1` and `revision2` is invalid
  - `path2` has no URL
  - `url1` was not found in `revision1`
  - the repository location of `path2` was not found in `revision2`
  - `dstPath` is not under version control

#### doMerge

    public void doMerge(SVNURL url1,
               SVNRevision revision1,
               java.io.File path2,
               SVNRevision revision2,
               java.io.File dstPath,
               SVNDepth depth,
               boolean useAncestry,
               boolean force,
               boolean dryRun,
               boolean recordOnly)
                 throws SVNException

Merges changes from `url1`/`revision1` to `path2`/`revision2` into the working-copy path `dstPath`.

`url1` and `path2` must both represent the same node kind - that is, if `url1` is a directory, `path2` must also be, and if `url1` is a file, `path2` must also be.

If `depth` is `SVNDepth.INFINITY`, merges fully recursively. Else if `SVNDepth.IMMEDIATES`, merges changes at most to files that are immediate children of `dstPath` and to directory properties of `dstPath` and its immediate subdirectory children. Else if `SVNDepth.FILES`, merges at most to immediate file children of `dstPath` and to `dstPath` itself. Else if `SVNDepth.EMPTY`, applies changes only to `dstPath` (i.e., directory property changes only).

If `depth` is `SVNDepth.UNKNOWN`, uses the depth of `dstPath`.

Uses `useAncestry` to control whether or not items being diffed will be checked for relatedness first. Unrelated items are typically transmitted to the editor as a deletion of one thing and the addition of another, but if this flag is true, unrelated items will be diffed as if they were related.

If `force` is not set and the merge involves deleting locally modified or unversioned items the operation will fail. If `force` is set such items will be deleted.

`merge options` is used to pass arguments to the merge processes (internal or external).

If the caller's `ISVNEventHandler` is not null, then it will be called once for each merged target.

If `recordOnly` is true, the merge isn't actually performed, but the mergeinfo for the revisions which would've been merged is recorded in the working copy (and must be subsequently committed back to the repository).

If `dryRun` is true, the merge is carried out, and full notification feedback is provided, but the working copy is not modified.

Note: this method requires repository access.

Parameters:
  `url1` - left-hand item - repository url
  `revision1` - revision of `url1`
  `path2` - right-hand item - working copy path
  `revision2` - revision of `path2`
  `dstPath` - target working copy path
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `force` - true to force the operation to run
  `dryRun` - if true then runs merge without any file changes
  `recordOnly` - if true, records only the rusult of merge - mergeinfo data
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either `revision1` or `revision2` is `invalid`
  exception with `SVNErrorCode.ENTRY_MISSING_URL` error code - if failed to retrieve the repository url of `path2`
Since:
  1.2, SVN 1.5

#### doMerge

    public void doMerge(SVNURL url1,
               SVNRevision revision1,
               SVNURL url2,
               SVNRevision revision2,
               java.io.File dstPath,
               boolean recursive,
               boolean useAncestry,
               boolean force,
               boolean dryRun)
                 throws SVNException

Deprecated. use `doMerge(SVNURL, SVNRevision, SVNURL, SVNRevision, File, SVNDepth, boolean, boolean, boolean, boolean)` instead
Applies the differences between two sources (one source URL against another source URL) to a Working Copy path.

Corresponds to the SVN command line client's `'svn merge sourceURL1@rev1 sourceURL2@rev2 WCPATH'` command.

If you need only to try merging your file(s) without actual merging, you should set `dryRun` to true. Your event handler will be dispatched status type information on the target path(s). If a path can be successfully merged, the status type will be `SVNStatusType.MERGED` for that path.

Parameters:
  `url1` - the first source URL
  `revision1` - a revision of `url1`
  `url2` - the second source URL that is to be compared against `url1`
  `revision2` - a revision of `url2`
  `dstPath` - the target path to which the result should be applied
  `recursive` - true to descend recursively
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `force` - true to force the operation to run
  `dryRun` - if true then only tries the operation to run (to find out if a file can be merged successfully)
Throws:
  `SVNException` - if one of the following is true:
  - at least one of `revision1` and `revision2` is invalid
  - `url1` was not found in `revision1`
  - `url2` was not found in `revision2`
  - `dstPath` is not under version control

#### doMerge

    public void doMerge(SVNURL url1,
               SVNRevision revision1,
               SVNURL url2,
               SVNRevision revision2,
               java.io.File dstPath,
               SVNDepth depth,
               boolean useAncestry,
               boolean force,
               boolean dryRun,
               boolean recordOnly)
                 throws SVNException

Merges changes from `url1`/`revision1` to `url2`/`revision2` into the working-copy path `dstPath`.

`url1` and `url2` must both represent the same node kind - that is, if `url1` is a directory, `url2` must also be, and if `url1` is a file, `url2` must also be.

If `depth` is `SVNDepth.INFINITY`, merges fully recursively. Else if `SVNDepth.IMMEDIATES`, merges changes at most to files that are immediate children of `dstPath` and to directory properties of `dstPath` and its immediate subdirectory children. Else if `SVNDepth.FILES`, merges at most to immediate file children of `dstPath` and to `dstPath` itself. Else if `SVNDepth.EMPTY`, applies changes only to `dstPath` (i.e., directory property changes only).

If `depth` is `SVNDepth.UNKNOWN`, uses the depth of `dstPath`.

Uses `useAncestry` to control whether or not items being diffed will be checked for relatedness first. Unrelated items are typically transmitted to the editor as a deletion of one thing and the addition of another, but if this flag is true, unrelated items will be diffed as if they were related.

If `force` is not set and the merge involves deleting locally modified or unversioned items the operation will fail. If `force` is set such items will be deleted.

`merge options` is used to pass arguments to the merge processes (internal or external).

If the caller's `ISVNEventHandler` is not null, then it will be called once for each merged target.

If `recordOnly` is true, the merge isn't actually performed, but the mergeinfo for the revisions which would've been merged is recorded in the working copy (and must be subsequently committed back to the repository).

If `dryRun` is true, the merge is carried out, and full notification feedback is provided, but the working copy is not modified.

Note: this method requires repository access.

Parameters:
  `url1` - left-hand repository url
  `revision1` - revision of `url1`
  `url2` - right-hand repository url
  `revision2` - revision of `url2`
  `dstPath` - target working copy path
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `force` - true to force the operation to run
  `dryRun` - if true then runs merge without any file changes
  `recordOnly` - if true, records only the rusult of merge - mergeinfo data
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` error code - if either `revision1` or `revision2` is `invalid`
Since:
  1.2, SVN 1.5

#### doMerge

    public void doMerge(SVNURL url1,
               SVNRevision pegRevision,
               SVNRevision revision1,
               SVNRevision revision2,
               java.io.File dstPath,
               boolean recursive,
               boolean useAncestry,
               boolean force,
               boolean dryRun)
                 throws SVNException

Deprecated. use `doMerge(SVNURL, SVNRevision, Collection, File, SVNDepth, boolean, boolean, boolean, boolean)` instead
Applies the differences between two sources (a source URL in a particular revision against the same source URL in another particular revision) to a Working Copy path.

Corresponds to the SVN command line client's `'svn merge -r rev1:rev2 URL@pegRev WCPATH'` command.

If you need only to try merging your file(s) without actual merging, you should set `dryRun` to true. Your event handler will be dispatched status type information on the target path(s). If a path can be successfully merged, the status type will be `SVNStatusType.MERGED` for that path.

Parameters:
  `url1` - a source URL
  `pegRevision` - a revision in which code>url1 is first looked up
  `revision1` - a left-hand revision of `url1`
  `revision2` - a right-hand revision of `url1`
  `dstPath` - the target path to which the result should be applied
  `recursive` - true to descend recursively
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `force` - true to force the operation to run
  `dryRun` - if true then only tries the operation to run (to find out if a file can be merged successfully)
Throws:
  `SVNException` - if one of the following is true:
  - at least one of `revision1`, `revision2` and `pegRevision` is invalid
  - `url1` was not found in `revision1`
  - `url1` was not found in `revision2`
  - `dstPath` is not under version control

#### doMerge

    public void doMerge(SVNURL url1,
               SVNRevision pegRevision,
               java.util.Collection<SVNRevisionRange> rangesToMerge,
               java.io.File dstPath,
               SVNDepth depth,
               boolean useAncestry,
               boolean force,
               boolean dryRun,
               boolean recordOnly)
                 throws SVNException

Merges the changes between `url1` in peg revision `pegRevision`, as it changed between the ranges described in `rangesToMerge`.

`rangesToMerge` is a collection of `SVNRevisionRange` ranges. These ranges may describe additive and/or subtractive merge ranges, they may overlap fully or partially, and/or they may partially or fully negate each other. This rangelist is not required to be sorted.

All other options are handled identically to `doMerge(SVNURL, SVNRevision, SVNURL, SVNRevision, File, SVNDepth, boolean, boolean, boolean, boolean)`.

Note: this method requires repository access.

Parameters:
  `url1` - a source URL
  `pegRevision` - a revision in which `url1` is first looked up
  `rangesToMerge` - collection of revision ranges to merge
  `dstPath` - target working copy path
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `force` - true to force the operation to run
  `dryRun` - if true then only tries the operation to run (to find out if a file can be merged successfully)
  `recordOnly` -
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` - If any revision in the list of provided ranges is `invalid`
Since:
  1.2, SVN 1.5

#### doMerge

    public void doMerge(java.io.File path1,
               SVNRevision pegRevision,
               SVNRevision revision1,
               SVNRevision revision2,
               java.io.File dstPath,
               boolean recursive,
               boolean useAncestry,
               boolean force,
               boolean dryRun)
                 throws SVNException

Deprecated. use `doMerge(File, SVNRevision, Collection, File, SVNDepth, boolean, boolean, boolean, boolean)` instead
Applies the differences between two sources (the repository location of a source Working Copy path in a particular revision against the repository location of the same path in another particular revision) to a Working Copy path.

Corresponds to the SVN command line client's `'svn merge -r rev1:rev2 sourceWCPATH@pegRev WCPATH'` command.

If you need only to try merging your file(s) without actual merging, you should set `dryRun` to true. Your event handler will be dispatched status type information on the target path(s). If a path can be successfully merged, the status type will be `SVNStatusType.MERGED` for that path.

Parameters:
  `path1` - a source WC path
  `pegRevision` - a revision in which the repository location of `path1` is first looked up
  `revision1` - a left-hand revision of `path1`
  `revision2` - a right-hand revision of `path1`
  `dstPath` - the target path to which the result should be applied
  `recursive` - true to descend recursively
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `force` - true to force the operation to run
  `dryRun` - if true then only tries the operation to run (to find out if a file can be merged successfully)
Throws:
  `SVNException` - if one of the following is true:
  - at least one of `revision1`, `revision2` and `pegRevision` is invalid
  - `path1` has no URL
  - the repository location of `path1` was not found in `revision1`
  - the repository location of `path1` was not found in `revision2`
  - `dstPath` is not under version control

#### doMerge

    public void doMerge(java.io.File path1,
               SVNRevision pegRevision,
               java.util.Collection<SVNRevisionRange> rangesToMerge,
               java.io.File dstPath,
               SVNDepth depth,
               boolean useAncestry,
               boolean force,
               boolean dryRun,
               boolean recordOnly)
                 throws SVNException

Merges the changes between `path1` in peg revision `pegRevision`, as it changed between the ranges described in `rangesToMerge`.

`rangesToMerge` is a collection of `SVNRevisionRange` ranges. These ranges may describe additive and/or subtractive merge ranges, they may overlap fully or partially, and/or they may partially or fully negate each other. This rangelist is not required to be sorted.

All other options are handled identically to `doMerge(File, SVNRevision, File, SVNRevision, File, SVNDepth, boolean, boolean, boolean, boolean)`.

Note: this method requires repository access.

Parameters:
  `path1` - working copy path
  `pegRevision` - a revision in which `path1` is first looked up
  `rangesToMerge` - collection of revision ranges to merge
  `dstPath` - target working copy path
  `depth` - tree depth to process
  `useAncestry` - if true then the paths ancestry will be noticed while calculating differences, otherwise not
  `force` - true to force the operation to run
  `dryRun` - if true then only tries the operation to run (to find out if a file can be merged successfully)
  `recordOnly` -
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.CLIENT_BAD_REVISION` - If any revision in the list of provided ranges is `invalid`
Since:
  1.2, SVN 1.5

#### isAllowMixedRevisionsWCForMerge

    public boolean isAllowMixedRevisionsWCForMerge()

#### doMergeReIntegrate

    public void doMergeReIntegrate(java.io.File srcPath,
                          SVNRevision pegRevision,
                          java.io.File dstPath,
                          boolean dryRun)
                            throws SVNException

Performs a reintegration merge of `srcPath` at `pegRevision` into `dstPath`.

`dstPath` must be a single-revision, `SVNDepth.INFINITY` , pristine, unswitched working copy -- in other words, it must reflect a single revision tree, the "target". The mergeinfo on `srcPath` must reflect that all of the target has been merged into it.

This kind of merge should be used for back merging (for example, merging branches back to trunk, in which case merge is carried out by comparing the latest trunk tree with the latest branch tree; i.e. the resulting difference is excatly the branch changes which will go back to trunk).

All other options are handled identically to `doMerge(File, SVNRevision, File, SVNRevision, File, SVNDepth, boolean, boolean, boolean, boolean)` . The depth of the merge is always `SVNDepth.INFINITY`.

If `pegRevision` is null or `invalid`, then it defaults to `SVNRevision.WORKING`.

Note: this method requires repository access.

Parameters:
  `srcPath` - working copy path
  `pegRevision` - a revision in which `srcPath` is first looked up
  `dstPath` - target working copy path
  `dryRun` - if true then only tries the operation to run (to find out if a file can be merged successfully)
Throws:
  `SVNException`
Since:
  1.2, SVN 1.5

#### doMergeReIntegrate

    public void doMergeReIntegrate(SVNURL srcURL,
                          SVNRevision pegRevision,
                          java.io.File dstPath,
                          boolean dryRun)
                            throws SVNException

Performs a reintegration merge of `srcURL` at `pegRevision` into `dstPath`.

`dstPath` must be a single-revision, `SVNDepth.INFINITY` , pristine, unswitched working copy -- in other words, it must reflect a single revision tree, the "target". The mergeinfo on `srcPath` must reflect that all of the target has been merged into it.

This kind of merge should be used for back merging (for example, merging branches back to trunk, in which case merge is carried out by comparing the latest trunk tree with the latest branch tree; i.e. the resulting difference is excatly the branch changes which will go back to trunk).

All other options are handled identically to `doMerge(SVNURL, SVNRevision, SVNURL, SVNRevision, File, SVNDepth, boolean, boolean, boolean, boolean)` . The depth of the merge is always `SVNDepth.INFINITY`.

If `pegRevision` is null or `invalid`, then it defaults to `SVNRevision.HEAD`.

Note: this method requires repository access.

Parameters:
  `srcURL` - repository url
  `pegRevision` - a revision in which `srcURL` is first looked up
  `dstPath` - target working copy path
  `dryRun` - if true then only tries the operation to run (to find out if a file can be merged successfully)
Throws:
  `SVNException`
Since:
  1.2, SVN 1.5

#### doGetLogMergedMergeInfo

    public void doGetLogMergedMergeInfo(java.io.File path,
                               SVNRevision pegRevision,
                               SVNURL mergeSrcURL,
                               SVNRevision srcPegRevision,
                               boolean discoverChangedPaths,
                               java.lang.String[] revisionProperties,
                               ISVNLogEntryHandler handler)
                                 throws SVNException

Drives a log entry `handler` with the revisions merged from `mergeSrcURL` (as of `srcPegRevision`) into `path` (as of `pegRevision`).

`discoverChangedPaths` and `revisionProperties` are the same as for `SVNLogClient.doLog(File[], SVNRevision, SVNRevision, SVNRevision, boolean, boolean, boolean, long, String[], ISVNLogEntryHandler)`.

Note: this routine requires repository access.

Parameters:
  `path` - working copy path (merge target)
  `pegRevision` - a revision in which `path` is first looked up
  `mergeSrcURL` - merge source repository url
  `srcPegRevision` - a revision in which `mergeSrcURL` is first looked up
  `discoverChangedPaths` - true to report of all changed paths for every revision being processed (those paths will be available by calling `SVNLogEntry.getChangedPaths()`)
  `revisionProperties` - names of revision properties to retrieve
  `handler` - the caller's log entry handler
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if the server doesn't support retrieval of mergeinfo
Since:
  1.2, SVN 1.5

#### doGetLogMergedMergeInfo

    public void doGetLogMergedMergeInfo(SVNURL url,
                               SVNRevision pegRevision,
                               SVNURL mergeSrcURL,
                               SVNRevision srcPegRevision,
                               boolean discoverChangedPaths,
                               java.lang.String[] revisionProperties,
                               ISVNLogEntryHandler handler)
                                 throws SVNException

Drives a log entry `handler` with the revisions merged from `mergeSrcURL` (as of `srcPegRevision`) into `url` (as of `pegRevision`).

`discoverChangedPaths` and `revisionProperties` are the same as for `SVNLogClient.doLog(File[], SVNRevision, SVNRevision, SVNRevision, boolean, boolean, boolean, long, String[], ISVNLogEntryHandler)`.

Note: this routine requires repository access.

Parameters:
  `url` - repository url (merge target)
  `pegRevision` - a revision in which `url` is first looked up
  `mergeSrcURL` - merge source repository url
  `srcPegRevision` - a revision in which `mergeSrcURL` is first looked up
  `discoverChangedPaths` - true to report of all changed paths for every revision being processed (those paths will be available by calling `SVNLogEntry.getChangedPaths()`)
  `revisionProperties` - names of revision properties to retrieve
  `handler` - the caller's log entry handler
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if the server doesn't support retrieval of mergeinfo
Since:
  1.2, SVN 1.5

#### doGetLogMergedMergeInfo

    public void doGetLogMergedMergeInfo(java.io.File path,
                               SVNRevision pegRevision,
                               java.io.File mergeSrcPath,
                               SVNRevision srcPegRevision,
                               boolean discoverChangedPaths,
                               java.lang.String[] revisionProperties,
                               ISVNLogEntryHandler handler)
                                 throws SVNException

Drives a log entry `handler` with the revisions merged from `mergeSrcPath` (as of `srcPegRevision`) into `path` (as of `pegRevision`).

`discoverChangedPaths` and `revisionProperties` are the same as for `SVNLogClient.doLog(File[], SVNRevision, SVNRevision, SVNRevision, boolean, boolean, boolean, long, String[], ISVNLogEntryHandler)`.

Note: this routine requires repository access.

Parameters:
  `path` - working copy path (merge target)
  `pegRevision` - a revision in which `path` is first looked up
  `mergeSrcPath` - merge source working copy path
  `srcPegRevision` - a revision in which `mergeSrcPath` is first looked up
  `discoverChangedPaths` - true to report of all changed paths for every revision being processed (those paths will be available by calling `SVNLogEntry.getChangedPaths()`)
  `revisionProperties` - names of revision properties to retrieve
  `handler` - the caller's log entry handler
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if the server doesn't support retrieval of mergeinfo
Since:
  1.2, SVN 1.5

#### doGetLogMergedMergeInfo

    public void doGetLogMergedMergeInfo(SVNURL url,
                               SVNRevision pegRevision,
                               java.io.File mergeSrcPath,
                               SVNRevision srcPegRevision,
                               boolean discoverChangedPaths,
                               java.lang.String[] revisionProperties,
                               ISVNLogEntryHandler handler)
                                 throws SVNException

Drives a log entry `handler` with the revisions merged from `mergeSrcPath` (as of `srcPegRevision`) into `url` (as of `pegRevision`).

`discoverChangedPaths` and `revisionProperties` are the same as for `SVNLogClient.doLog(File[], SVNRevision, SVNRevision, SVNRevision, boolean, boolean, boolean, long, String[], ISVNLogEntryHandler)`.

Note: this routine requires repository access.

Parameters:
  `url` - repository url (merge target)
  `pegRevision` - a revision in which `url` is first looked up
  `mergeSrcPath` - merge source working copy path
  `srcPegRevision` - a revision in which `mergeSrcPath` is first looked up
  `discoverChangedPaths` - true to report of all changed paths for every revision being processed (those paths will be available by calling `SVNLogEntry.getChangedPaths()`)
  `revisionProperties` - names of revision properties to retrieve
  `handler` - the caller's log entry handler
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if the server doesn't support retrieval of mergeinfo
Since:
  1.2, SVN 1.5

#### doGetLogEligibleMergeInfo

    public void doGetLogEligibleMergeInfo(java.io.File path,
                                 SVNRevision pegRevision,
                                 SVNURL mergeSrcURL,
                                 SVNRevision srcPegRevision,
                                 boolean discoverChangedPaths,
                                 java.lang.String[] revisionProperties,
                                 ISVNLogEntryHandler handler)
                                   throws SVNException

Drives a log entry `handler` with the revisions eligible for merge from `mergeSrcURL` (as of `srcPegRevision`) into `path` (as of `pegRevision`).

`discoverChangedPaths` and `revisionProperties` are the same as for `SVNLogClient.doLog(File[], SVNRevision, SVNRevision, SVNRevision, boolean, boolean, boolean, long, String[], ISVNLogEntryHandler)`.

Note: this routine requires repository access.

Parameters:
  `path` - working copy path (merge target)
  `pegRevision` - a revision in which `path` is first looked up
  `mergeSrcURL` - merge source repository url
  `srcPegRevision` - a revision in which `mergeSrcURL` is first looked up
  `discoverChangedPaths` - true to report of all changed paths for every revision being processed (those paths will be available by calling `SVNLogEntry.getChangedPaths()`)
  `revisionProperties` - names of revision properties to retrieve
  `handler` - the caller's log entry handler
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if the server doesn't support retrieval of mergeinfo
Since:
  1.2, SVN 1.5

#### doGetLogEligibleMergeInfo

    public void doGetLogEligibleMergeInfo(SVNURL url,
                                 SVNRevision pegRevision,
                                 SVNURL mergeSrcURL,
                                 SVNRevision srcPegRevision,
                                 boolean discoverChangedPaths,
                                 java.lang.String[] revisionProperties,
                                 ISVNLogEntryHandler handler)
                                   throws SVNException

Drives a log entry `handler` with the revisions eligible for merge from `mergeSrcURL` (as of `srcPegRevision`) into `url` (as of `pegRevision`).

`discoverChangedPaths` and `revisionProperties` are the same as for `SVNLogClient.doLog(File[], SVNRevision, SVNRevision, SVNRevision, boolean, boolean, boolean, long, String[], ISVNLogEntryHandler)`.

Note: this routine requires repository access.

Parameters:
  `url` - repository url (merge target)
  `pegRevision` - a revision in which `url` is first looked up
  `mergeSrcURL` - merge source repository url
  `srcPegRevision` - a revision in which `mergeSrcURL` is first looked up
  `discoverChangedPaths` - true to report of all changed paths for every revision being processed (those paths will be available by calling `SVNLogEntry.getChangedPaths()`)
  `revisionProperties` - names of revision properties to retrieve
  `handler` - the caller's log entry handler
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if the server doesn't support retrieval of mergeinfo
Since:
  1.2, SVN 1.5

#### doGetLogEligibleMergeInfo

    public void doGetLogEligibleMergeInfo(java.io.File path,
                                 SVNRevision pegRevision,
                                 java.io.File mergeSrcPath,
                                 SVNRevision srcPegRevision,
                                 boolean discoverChangedPaths,
                                 java.lang.String[] revisionProperties,
                                 ISVNLogEntryHandler handler)
                                   throws SVNException

Drives a log entry `handler` with the revisions eligible for merge from `mergeSrcPath` (as of `srcPegRevision`) into `path` (as of `pegRevision`).

`discoverChangedPaths` and `revisionProperties` are the same as for `SVNLogClient.doLog(File[], SVNRevision, SVNRevision, SVNRevision, boolean, boolean, boolean, long, String[], ISVNLogEntryHandler)`.

Note: this routine requires repository access.

Parameters:
  `path` - working copy path (merge target)
  `pegRevision` - a revision in which `path` is first looked up
  `mergeSrcPath` - merge source working copy path
  `srcPegRevision` - a revision in which `mergeSrcPath` is first looked up
  `discoverChangedPaths` - true to report of all changed paths for every revision being processed (those paths will be available by calling `SVNLogEntry.getChangedPaths()`)
  `revisionProperties` - names of revision properties to retrieve
  `handler` - the caller's log entry handler
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if the server doesn't support retrieval of mergeinfo
Since:
  1.2, SVN 1.5

#### doGetLogEligibleMergeInfo

    public void doGetLogEligibleMergeInfo(SVNURL url,
                                 SVNRevision pegRevision,
                                 java.io.File mergeSrcPath,
                                 SVNRevision srcPegRevision,
                                 boolean discoverChangedPaths,
                                 java.lang.String[] revisionProperties,
                                 ISVNLogEntryHandler handler)
                                   throws SVNException

Drives a log entry `handler` with the revisions eligible for merge from `mergeSrcPath` (as of `srcPegRevision`) into `url` (as of `pegRevision`).

`discoverChangedPaths` and `revisionProperties` are the same as for `SVNLogClient.doLog(File[], SVNRevision, SVNRevision, SVNRevision, boolean, boolean, boolean, long, String[], ISVNLogEntryHandler)`.

Note: this routine requires repository access.

Parameters:
  `url` - repository url (merge target)
  `pegRevision` - a revision in which `url` is first looked up
  `mergeSrcPath` - merge source working copy path
  `srcPegRevision` - a revision in which `mergeSrcPath` is first looked up
  `discoverChangedPaths` - true to report of all changed paths for every revision being processed (those paths will be available by calling `SVNLogEntry.getChangedPaths()`)
  `revisionProperties` - names of revision properties to retrieve
  `handler` - the caller's log entry handler
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if the server doesn't support retrieval of mergeinfo
Since:
  1.2, SVN 1.5

#### doGetMergedMergeInfo

    public java.util.Map<SVNURL,SVNMergeRangeList> doGetMergedMergeInfo(java.io.File path,
                                                               SVNRevision pegRevision)
                                                                 throws SVNException

Returns mergeinfo as a `Map` with merge source URLs (as `SVNURL`) mapped to range lists (`SVNMergeRangeList`). Range lists are objects containing arrays of `ranges` describing the ranges which have been merged into `path` as of `pegRevision`. If there is no mergeinfo, returns null.

Note: unlike most APIs which deal with mergeinfo, this one returns data where the keys of the map are absolute repository URLs rather than repository filesystem paths.

Note: this routine requires repository access.

Parameters:
  `path` - working copy path
  `pegRevision` - a revision in which `path` is first looked up
Returns:
  mergeinfo for `path`
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if the server doesn't support retrieval of mergeinfo (which will never happen for file:// URLs)
Since:
  1.2, SVN 1.5

#### doGetMergedMergeInfo

    public java.util.Map<SVNURL,SVNMergeRangeList> doGetMergedMergeInfo(SVNURL url,
                                                               SVNRevision pegRevision)
                                                                 throws SVNException

Returns mergeinfo as a `Map` with merge source URLs (as `SVNURL`) mapped to range lists (`SVNMergeRangeList`). Range lists are objects containing arrays of `ranges` describing the ranges which have been merged into `url` as of `pegRevision`. If there is no mergeinfo, returns null.

Note: unlike most APIs which deal with mergeinfo, this one returns data where the keys of the map are absolute repository URLs rather than repository filesystem paths.

Note: this routine requires repository access.

Parameters:
  `url` - repository url
  `pegRevision` - a revision in which `url` is first looked up
Returns:
  mergeinfo for `url`
Throws:
  `SVNException` - in the following cases:
  exception with `SVNErrorCode.UNSUPPORTED_FEATURE` error code - if the server doesn't support retrieval of mergeinfo (which will never happen for file:// URLs)
Since:
  1.2, SVN 1.5

#### doSuggestMergeSources

    public java.util.Collection<SVNURL> doSuggestMergeSources(java.io.File path,
                                                     SVNRevision pegRevision)
                                                       throws SVNException

Returns a collection of potential merge sources (expressed as full repository `URLs`) for `path` at `pegRevision`.

Parameters:
  `path` - working copy path
  `pegRevision` - a revision in which `path` is first looked up
Returns:
  potential merge sources for `path`
Throws:
  `SVNException`
Since:
  1.2, SVN 1.5

#### doSuggestMergeSources

    public java.util.Collection<SVNURL> doSuggestMergeSources(SVNURL url,
                                                     SVNRevision pegRevision)
                                                       throws SVNException

Returns a collection of potential merge sources (expressed as full repository `URLs`) for `url` at `pegRevision`.

Parameters:
  `url` - repository url
  `pegRevision` - a revision in which `url` is first looked up
Returns:
  potential merge sources for `url`
Throws:
  `SVNException`
Since:
  1.2, SVN 1.5

#### doPatch

    public void doPatch(java.io.File absPatchPath,
               java.io.File localAbsPath,
               boolean dryRun,
               int stripCount)
                 throws SVNException

Throws:
  `SVNException`

#### setAllowMixedRevisionsWCForMerge

    public void setAllowMixedRevisionsWCForMerge(boolean allowMixedRevisions)

#### isShowCopiesAsAdds

    public boolean isShowCopiesAsAdds()

#### setShowCopiesAsAdds

    public void setShowCopiesAsAdds(boolean showCopiesAsAdds)

#### isGitDiffFormat

    public boolean isGitDiffFormat()

#### setGitDiffFormat

    public void setGitDiffFormat(boolean gitDiffFormat)