Overview | Package | Class | Tree | Deprecated | Index | Help
| JavaSVN Home
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.tmatesoft.svn.core.wc
Class SVNDiffClient

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

All Implemented Interfaces:
  ISVNEventHandler

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:

JavaSVN | Subversion
doDiff() | 'svn diff'
doMerge() | 'svn merge'

Version:
  1.0
Author:
  TMate Software Ltd.

Nested Class Summary

Nested classes inherited from class org.tmatesoft.svn.core.wc.SVNBasicClient
`SVNBasicClient.RepositoryReference, SVNBasicClient.SVNRepositoryLocation`

Field Summary

Fields inherited from interface org.tmatesoft.svn.core.wc.ISVNEventHandler
`UNKNOWN`

Constructor Summary
`` | `SVNDiffClient(ISVNAuthenticationManager authManager, ISVNOptions options)` Constructs and initializes an SVNDiffClient object with the specified run-time configuration and authentication drivers.
`protected` | `SVNDiffClient(ISVNRepositoryPool repositoryPool, ISVNOptions options)`

Method Summary
`void` | `doDiff(File path1, SVNRevision rN, File path2, SVNRevision rM, boolean recursive, boolean useAncestry, OutputStream result)` 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.
`void` | `doDiff(File path, SVNRevision pegRevision, SVNRevision rN, SVNRevision rM, boolean recursive, boolean useAncestry, OutputStream result)` Generates the differences for the specified path taken from the two specified revisions and writes the result to the provided output stream.
`void` | `doDiff(File path1, SVNRevision rN, SVNURL url2, SVNRevision rM, boolean recursive, boolean useAncestry, OutputStream result)` 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.
`void` | `doDiff(SVNURL url1, SVNRevision rN, File path2, SVNRevision rM, boolean recursive, boolean useAncestry, OutputStream result)` 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.
`void` | `doDiff(SVNURL url, SVNRevision pegRevision, SVNRevision rN, SVNRevision rM, boolean recursive, boolean useAncestry, OutputStream result)` Generates the differences for the specified URL taken from the two specified revisions and writes the result to the provided output stream.
`void` | `doDiff(SVNURL url1, SVNRevision rN, SVNURL url2, SVNRevision rM, boolean recursive, boolean useAncestry, OutputStream result)` Generates the differences for the specified URLs taken from the two specified revisions and writes the result to the provided output stream.
`void` | `doMerge(File path1, SVNRevision revision1, File path2, SVNRevision revision2, File dstPath, boolean recusrsive, boolean useAncestry, boolean force, boolean dryRun)` Applies the differences between two sources (using Working Copy paths to get corresponding URLs of the sources) to a Working Copy path.
`void` | `doMerge(File path1, SVNRevision pegRevision, SVNRevision revision1, SVNRevision revision2, File dstPath, boolean recusrsive, boolean useAncestry, boolean force, boolean dryRun)` 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.
`void` | `doMerge(File path1, SVNRevision revision1, SVNURL url2, SVNRevision revision2, File dstPath, boolean recusrsive, boolean useAncestry, boolean force, boolean dryRun)` 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.
`void` | `doMerge(SVNURL url1, SVNRevision revision1, File path2, SVNRevision revision2, File dstPath, boolean recusrsive, boolean useAncestry, boolean force, boolean dryRun)` Applies the differences between two sources (the repository location URL of a source Working Copy against a source URL) to a Working Copy path.
`void` | `doMerge(SVNURL url1, SVNRevision pegRevision, SVNRevision revision1, SVNRevision revision2, File dstPath, boolean recusrsive, boolean useAncestry, boolean force, boolean dryRun)` 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.
`void` | `doMerge(SVNURL url1, SVNRevision revision1, SVNURL url2, SVNRevision revision2, File dstPath, boolean recusrsive, boolean useAncestry, boolean force, boolean dryRun)` Applies the differences between two sources (one source URL against another source URL) to a Working Copy path.
`ISVNDiffGenerator` | `getDiffGenerator()` Returns the diff driver being in use.
`void` | `setDiffGenerator(ISVNDiffGenerator diffGenerator)` Sets the specified diff driver for this object to use for generating and writing file differences to an otput stream.

Methods inherited from class org.tmatesoft.svn.core.wc.SVNBasicClient
`checkCancelled, createRepository, createRepository, createRepository, createWCAccess, createWCAccess, dispatchEvent, dispatchEvent, getEventDispatcher, getLocations, getOptions, getRepositoryPool, getRevisionNumber, getURL, handleEvent, isIgnoreExternals, isLeaveConflictsUnresolved, setEventHandler, setEventPathPrefix, setIgnoreExternals, setLeaveConflictsUnresolved, sleepForTimeStamp`

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

    protected SVNDiffClient(ISVNRepositoryPool repositoryPool,
                            ISVNOptions options)

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)`

### doDiff

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

  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(File path,
                       SVNRevision pegRevision,
                       SVNRevision rN,
                       SVNRevision rM,
                       boolean recursive,
                       boolean useAncestry,
                       OutputStream result)
                throws SVNException

  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 file 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(SVNURL url1,
                       SVNRevision rN,
                       SVNURL url2,
                       SVNRevision rM,
                       boolean recursive,
                       boolean useAncestry,
                       OutputStream result)
                throws SVNException

  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(File path1,
                       SVNRevision rN,
                       SVNURL url2,
                       SVNRevision rM,
                       boolean recursive,
                       boolean useAncestry,
                       OutputStream result)
                throws SVNException

  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(SVNURL url1,
                       SVNRevision rN,
                       File path2,
                       SVNRevision rM,
                       boolean recursive,
                       boolean useAncestry,
                       OutputStream result)
                throws SVNException

  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(File path1,
                       SVNRevision rN,
                       File path2,
                       SVNRevision rM,
                       boolean recursive,
                       boolean useAncestry,
                       OutputStream result)
                throws SVNException

  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`

### doMerge

    public void doMerge(File path1,
                        SVNRevision revision1,
                        File path2,
                        SVNRevision revision2,
                        File dstPath,
                        boolean recusrsive,
                        boolean useAncestry,
                        boolean force,
                        boolean dryRun)
                 throws SVNException

  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
    `recusrsive` - 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(File path1,
                        SVNRevision revision1,
                        SVNURL url2,
                        SVNRevision revision2,
                        File dstPath,
                        boolean recusrsive,
                        boolean useAncestry,
                        boolean force,
                        boolean dryRun)
                 throws SVNException

  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
    `recusrsive` - 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(SVNURL url1,
                        SVNRevision revision1,
                        File path2,
                        SVNRevision revision2,
                        File dstPath,
                        boolean recusrsive,
                        boolean useAncestry,
                        boolean force,
                        boolean dryRun)
                 throws SVNException

  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
    `recusrsive` - 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,
                        SVNURL url2,
                        SVNRevision revision2,
                        File dstPath,
                        boolean recusrsive,
                        boolean useAncestry,
                        boolean force,
                        boolean dryRun)
                 throws SVNException

  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
    `recusrsive` - 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 pegRevision,
                        SVNRevision revision1,
                        SVNRevision revision2,
                        File dstPath,
                        boolean recusrsive,
                        boolean useAncestry,
                        boolean force,
                        boolean dryRun)
                 throws SVNException

  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
    `recusrsive` - 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(File path1,
                        SVNRevision pegRevision,
                        SVNRevision revision1,
                        SVNRevision revision2,
                        File dstPath,
                        boolean recusrsive,
                        boolean useAncestry,
                        boolean force,
                        boolean dryRun)
                 throws SVNException

  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
    `recusrsive` - 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

Overview | Package | Class | Tree | Deprecated | Index | Help
| JavaSVN Home
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2004-2006 TMate Software Ltd. All Rights Reserved.