Class SVNUpdateClient16

  • All Implemented Interfaces:
    ISVNCanceller, ISVNEventHandler

    public class SVNUpdateClient16
    extends SVNBasicDelegate
    This class provides methods which allow to check out, update, switch and relocate a Working Copy as well as export an unversioned directory or file from a repository.

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

    SVNKit Subversion
    doCheckout() 'svn checkout'
    doUpdate() 'svn update'
    doSwitch() 'svn switch'
    doRelocate() 'svn switch --relocate oldURL newURL'
    doExport() 'svn export'
    Since:
    1.2
    Version:
    1.3
    See Also:
    Examples
    • Field Detail

      • myIsUpdateLocksOnDemand

        private boolean myIsUpdateLocksOnDemand
      • myIsExportExpandsKeywords

        private boolean myIsExportExpandsKeywords
    • Constructor Detail

      • SVNUpdateClient16

        public SVNUpdateClient16​(ISVNAuthenticationManager authManager,
                                 ISVNOptions options)
        Constructs and initializes an SVNUpdateClient object with the specified run-time configuration and authentication drivers.

        If options is null, then this SVNUpdateClient 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 SVNUpdateClient 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
      • SVNUpdateClient16

        public SVNUpdateClient16​(ISVNRepositoryPool repositoryPool,
                                 ISVNOptions options)
        Constructs and initializes an SVNUpdateClient object with the specified run-time configuration and authentication drivers.

        If options is null, then this SVNUpdateClient 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

      • doUpdate

        public long doUpdate​(java.io.File file,
                             SVNRevision revision,
                             boolean recursive)
                      throws SVNException
        Brings the Working Copy item up-to-date with repository changes at the specified revision.

        As a revision SVNRevision's pre-defined constant fields can be used. For example, to update the Working Copy to the latest revision of the repository use HEAD.

        Parameters:
        file - the Working copy item to be updated
        revision - the desired revision against which the item will be updated
        recursive - if true and file is a directory then the entire tree will be updated, otherwise if false - only items located immediately in the directory itself
        Returns:
        the revision number to which file was updated to
        Throws:
        SVNException
      • doUpdate

        public long[] doUpdate​(java.io.File[] paths,
                               SVNRevision revision,
                               SVNDepth depth,
                               boolean allowUnversionedObstructions,
                               boolean depthIsSticky)
                        throws SVNException
        Updates working trees paths to revision. Unversioned paths that are direct children of a versioned path will cause an update that attempts to add that path, other unversioned paths are skipped.

        revision must represent a valid revision number ( SVNRevision.getNumber() >= 0), or date ( SVNRevision.getDate() != true), or be equal to SVNRevision.HEAD. If revision does not meet these requirements, an exception with the error code SVNErrorCode.CLIENT_BAD_REVISION is thrown.

        The paths in paths can be from multiple working copies from multiple repositories, but even if they all come from the same repository there is no guarantee that revision represented by SVNRevision.HEADwill remain the same as each path is updated.

        If externals are ignored, doesn't process externals definitions as part of this operation.

        If depth is SVNDepth.INFINITY, updates fully recursively. Else if it is SVNDepth.IMMEDIATES or SVNDepth.FILES, updates each target and its file entries, but not its subdirectories. Else if SVNDepth.EMPTY, updates exactly each target, nonrecursively (essentially, updates the target's properties).

        If depth is SVNDepth.UNKNOWN, takes the working depth from paths and then behaves as described above.

        If depthIsSticky is set and depth is not SVNDepth.UNKNOWN, then in addition to updating paths , also sets their sticky ambient depth value to depth.

        If allowUnversionedObstructions is true then the update tolerates existing unversioned items that obstruct added paths. Only obstructions of the same type (file or dir) as the added item are tolerated. The text of obstructing files is left as-is, effectively treating it as a user modification after the update. Working properties of obstructing items are set equal to the base properties. If allowUnversionedObstructions is false then the update will abort if there are any unversioned obstructing items.

        If the caller's ISVNEventHandler is non-null, it is invoked for each item handled by the update, and also for files restored from text-base. Also ISVNCanceller.checkCancelled() will be used at various places during the update to check whether the caller wants to stop the update.

        Before updating a next path from paths this method calls SVNBasicDelegate.handlePathListItem(File) passing the path to it.

        This operation requires repository access (in case the repository is not on the same machine, network connection is established).

        Parameters:
        paths - working copy paths
        revision - revision to update to
        depth - tree depth to update
        allowUnversionedObstructions - flag that allows tolerating unversioned items during update
        depthIsSticky - flag that controls whether the requested depth should be written to the working copy
        Returns:
        an array of long revisions with each element set to the revision to which revision was resolved
        Throws:
        SVNException
        Since:
        1.2, SVN 1.5
      • doUpdate

        public long doUpdate​(java.io.File path,
                             SVNRevision revision,
                             SVNDepth depth,
                             boolean allowUnversionedObstructions,
                             boolean depthIsSticky)
                      throws SVNException
        Updates working copy to revision. Unversioned paths that are direct children of a versioned path will cause an update that attempts to add that path, other unversioned paths are skipped.

        revision must represent a valid revision number ( SVNRevision.getNumber() >= 0), or date ( SVNRevision.getDate() != true), or be equal to SVNRevision.HEAD. If revision does not meet these requirements, an exception with the error code SVNErrorCode.CLIENT_BAD_REVISION is thrown.

        If externals are ignored, doesn't process externals definitions as part of this operation.

        If depth is SVNDepth.INFINITY, updates fully recursively. Else if it is SVNDepth.IMMEDIATES or SVNDepth.FILES, updates path and its file entries, but not its subdirectories. Else if SVNDepth.EMPTY, updates exactly path, nonrecursively (essentially, updates the target's properties).

        If depth is SVNDepth.UNKNOWN, takes the working depth from path and then behaves as described above.

        If depthIsSticky is set and depth is not SVNDepth.UNKNOWN, then in addition to updating path, also sets its sticky ambient depth value to depth.

        If allowUnversionedObstructions is true then the update tolerates existing unversioned items that obstruct added paths. Only obstructions of the same type (file or dir) as the added item are tolerated. The text of obstructing files is left as-is, effectively treating it as a user modification after the update. Working properties of obstructing items are set equal to the base properties. If allowUnversionedObstructions is false then the update will abort if there are any unversioned obstructing items.

        If the caller's ISVNEventHandler is non-null, it is invoked for each item handled by the update, and also for files restored from text-base. Also ISVNCanceller.checkCancelled() will be used at various places during the update to check whether the caller wants to stop the update.

        This operation requires repository access (in case the repository is not on the same machine, network connection is established).

        Parameters:
        path - working copy path
        revision - revision to update to
        depth - tree depth to update
        allowUnversionedObstructions - flag that allows tollerating unversioned items during update
        depthIsSticky - flag that controls whether the requested depth should be written to the working copy
        Returns:
        revision to which revision was resolved
        Throws:
        SVNException
        Since:
        1.2, SVN 1.5
      • update

        private long update​(java.io.File path,
                            SVNRevision revision,
                            SVNDepth depth,
                            boolean allowUnversionedObstructions,
                            boolean depthIsSticky,
                            boolean sendCopyFrom)
                     throws SVNException
        Throws:
        SVNException
      • setUpdateLocksOnDemand

        public void setUpdateLocksOnDemand​(boolean locksOnDemand)
        Sets whether working copies should be locked on demand or not during an update process.

        For additional description, please, refer to isUpdateLocksOnDemand().

        Parameters:
        locksOnDemand - true to make update lock a working copy tree on demand only (for those subdirectories only which will be changed by update)
      • isUpdateLocksOnDemand

        public boolean isUpdateLocksOnDemand()
        Says whether the entire working copy should be locked while updating or not.

        If this method returns false, then the working copy will be closed for all paths involved in the update. Otherwise only those working copy subdirectories will be locked, which will be either changed by the update or which contain deleted files that should be restored during the update; all other versioned subdirectories than won't be touched by the update will remain opened for read only access without locking.

        Locking working copies on demand is intended to improve update performance for large working copies because even a no-op update on a huge working copy always locks the entire tree by default. And locking a working copy tree means opening special lock files for privileged access for all subdirectories involved. This makes an update process work slower. Locking wc on demand feature suggests such a workaround to enhance update performance.

        Returns:
        true when locking wc on demand
      • doSwitch

        public long doSwitch​(java.io.File file,
                             SVNURL url,
                             SVNRevision revision,
                             boolean recursive)
                      throws SVNException
        Updates the Working Copy item to mirror a new URL.

        As a revision SVNRevision's pre-defined constant fields can be used. For example, to update the Working Copy to the latest revision of the repository use HEAD.

        Calling this method is equivalent to doSwitch(file, url, SVNRevision.UNDEFINED, revision, recursive).

        Parameters:
        file - the Working copy item to be switched
        url - the repository location as a target against which the item will be switched
        revision - the desired revision of the repository target
        recursive - if true and file is a directory then the entire tree will be updated, otherwise if false - only items located immediately in the directory itself
        Returns:
        the revision number to which file was updated to
        Throws:
        SVNException
      • doSwitch

        public long doSwitch​(java.io.File file,
                             SVNURL url,
                             SVNRevision pegRevision,
                             SVNRevision revision,
                             boolean recursive)
                      throws SVNException
        Updates the Working Copy item to mirror a new URL.

        As a revision SVNRevision's pre-defined constant fields can be used. For example, to update the Working Copy to the latest revision of the repository use HEAD.

        Parameters:
        file - the Working copy item to be switched
        url - the repository location as a target against which the item will be switched
        pegRevision - a revision in which file is first looked up in the repository
        revision - the desired revision of the repository target
        recursive - if true and file is a directory then the entire tree will be updated, otherwise if false - only items located immediately in the directory itself
        Returns:
        the revision number to which file was updated to
        Throws:
        SVNException
      • doSwitch

        public long doSwitch​(java.io.File path,
                             SVNURL url,
                             SVNRevision pegRevision,
                             SVNRevision revision,
                             SVNDepth depth,
                             boolean allowUnversionedObstructions,
                             boolean depthIsSticky)
                      throws SVNException
        Switches working tree path to url\ pegRevision at revision.

        Summary of purpose: this is normally used to switch a working directory over to another line of development, such as a branch or a tag. Switching an existing working directory is more efficient than checking out url from scratch.

        revision must represent a valid revision number ( SVNRevision.getNumber() >= 0), or date ( SVNRevision.getDate() != true), or be equal to SVNRevision.HEAD. If revision does not meet these requirements, an exception with the error code SVNErrorCode.CLIENT_BAD_REVISION is thrown.

        If depth is SVNDepth.INFINITY, switches fully recursively. Else if it is SVNDepth.IMMEDIATES, switches path and its file children (if any), and switches subdirectories but does not update them. Else if SVNDepth.FILES, switches just file children, ignoring subdirectories completely. Else if SVNDepth.EMPTY, switches just path and touches nothing underneath it.

        If depthIsSticky is set and depth is not SVNDepth.UNKNOWN, then in addition to switching path , also sets its sticky ambient depth value to depth.

        If externals are ignored, doesn't process externals definitions as part of this operation.

        If allowUnversionedObstructions is true then the switch tolerates existing unversioned items that obstruct added paths. Only obstructions of the same type (file or dir) as the added item are tolerated. The text of obstructing files is left as-is, effectively treating it as a user modification after the switch. Working properties of obstructing items are set equal to the base properties. If allowUnversionedObstructions is false then the switch will abort if there are any unversioned obstructing items.

        If the caller's ISVNEventHandler is non-null, it is invoked for paths affected by the switch, and also for files restored from text-base. Also ISVNCanceller.checkCancelled() will be used at various places during the switch to check whether the caller wants to stop the switch.

        This operation requires repository access (in case the repository is not on the same machine, network connection is established).

        Parameters:
        path - the Working copy item to be switched
        url - the repository location as a target against which the item will be switched
        pegRevision - a revision in which path is first looked up in the repository
        revision - the desired revision of the repository target
        depth - tree depth to update
        allowUnversionedObstructions - flag that allows tolerating unversioned items during update
        depthIsSticky - flag that controls whether the requested depth should be written into the working copy
        Returns:
        value of the revision to which the working copy was actually switched
        Throws:
        SVNException
        Since:
        1.2, SVN 1.5
      • doCheckout

        public long doCheckout​(SVNURL url,
                               java.io.File dstPath,
                               SVNRevision pegRevision,
                               SVNRevision revision,
                               boolean recursive)
                        throws SVNException
        Checks out a Working Copy from a repository.

        If the destination path (dstPath) is null then the last component of url is used for the local directory name.

        As a revision SVNRevision's pre-defined constant fields can be used. For example, to check out a Working Copy at the latest revision of the repository use HEAD.

        Parameters:
        url - a repository location from where a Working Copy will be checked out
        dstPath - the local path where the Working Copy will be placed
        pegRevision - the revision at which url will be firstly seen in the repository to make sure it's the one that is needed
        revision - the desired revision of the Working Copy to be checked out
        recursive - if true and url is a directory then the entire tree will be checked out, otherwise if false - only items located immediately in the directory itself
        Returns:
        the revision number of the Working Copy
        Throws:
        SVNException - url refers to a file, not a directory; dstPath already exists but it is a file, not a directory; dstPath already exists and is a versioned directory but has a different URL (repository location against which the directory is controlled)
      • doCheckout

        public long doCheckout​(SVNURL url,
                               java.io.File dstPath,
                               SVNRevision pegRevision,
                               SVNRevision revision,
                               SVNDepth depth,
                               boolean allowUnversionedObstructions)
                        throws SVNException
        Checks out a working copy of url at revision, looked up at pegRevision, using dstPath as the root directory of the newly checked out working copy.

        If pegRevision is SVNRevision.UNDEFINED, then it defaults to SVNRevision.HEAD.

        revision must represent a valid revision number ( SVNRevision.getNumber() >= 0), or date ( SVNRevision.getDate() != true), or be equal to SVNRevision.HEAD. If revision does not meet these requirements, an exception with the error code SVNErrorCode.CLIENT_BAD_REVISION is thrown.

        If depth is SVNDepth.INFINITY, checks out fully recursively. Else if it is SVNDepth.IMMEDIATES, checks out url and its immediate entries (subdirectories will be present, but will be at depth SVNDepth.EMPTY themselves); else SVNDepth.FILES, checks out url and its file entries, but no subdirectories; else if SVNDepth.EMPTY, checks out url as an empty directory at that depth, with no entries present.

        If depth is SVNDepth.UNKNOWN, then behave as if for SVNDepth.INFINITY, except in the case of resuming a previous checkout of dstPath (i.e., updating), in which case uses the depth of the existing working copy.

        If externals are ignored, doesn't process externals definitions as part of this operation.

        If allowUnversionedObstructions is true then the checkout tolerates existing unversioned items that obstruct added paths from url. Only obstructions of the same type (file or dir) as the added item are tolerated. The text of obstructing files is left as-is, effectively treating it as a user modification after the checkout. Working properties of obstructing items are set equal to the base properties. If allowUnversionedObstructions is false then the checkout will abort if there are any unversioned obstructing items.

        If the caller's ISVNEventHandler is non-null, it is invoked as the checkout processes. Also ISVNCanceller.checkCancelled() will be used at various places during the checkout to check whether the caller wants to stop the checkout.

        This operation requires repository access (in case the repository is not on the same machine, network connection is established).

        Parameters:
        url - a repository location from where a Working Copy will be checked out
        dstPath - the local path where the Working Copy will be placed
        pegRevision - the revision at which url will be firstly seen in the repository to make sure it's the one that is needed
        revision - the desired revision of the Working Copy to be checked out
        depth - tree depth
        allowUnversionedObstructions - flag that allows tolerating unversioned items during
        Returns:
        value of the revision actually checked out from the repository
        Throws:
        SVNException -
        Since:
        1.2, SVN 1.5
      • doExport

        public long doExport​(SVNURL url,
                             java.io.File dstPath,
                             SVNRevision pegRevision,
                             SVNRevision revision,
                             java.lang.String eolStyle,
                             boolean force,
                             boolean recursive)
                      throws SVNException
        Exports a clean directory or single file from a repository.

        If eolStyle is not null then it should denote a specific End-Of-Line marker for the files to be exported. Significant values for eolStyle are:

        • "CRLF" (Carriage Return Line Feed) - this causes files to contain '\r\n' line ending sequences for EOL markers, regardless of the operating system in use (for instance, this EOL marker is used by software on the Windows platform).
        • "LF" (Line Feed) - this causes files to contain '\n' line ending sequences for EOL markers, regardless of the operating system in use (for instance, this EOL marker is used by software on the Unix platform).
        • "CR" (Carriage Return) - this causes files to contain '\r' line ending sequences for EOL markers, regardless of the operating system in use (for instance, this EOL marker was used by software on older Macintosh platforms).
        • "native" - this causes files to contain the EOL markers that are native to the operating system on which SVNKit is run.
        Parameters:
        url - a repository location from where the unversioned directory/file will be exported
        dstPath - the local path where the repository items will be exported to
        pegRevision - the revision at which url will be firstly seen in the repository to make sure it's the one that is needed
        revision - the desired revision of the directory/file to be exported
        eolStyle - a string that denotes a specific End-Of-Line character;
        force - true to fore the operation even if there are local files with the same names as those in the repository (local ones will be replaced)
        recursive - if true and url is a directory then the entire tree will be exported, otherwise if false - only items located immediately in the directory itself
        Returns:
        the revision number of the exported directory/file
        Throws:
        SVNException
      • doExport

        public long doExport​(SVNURL url,
                             java.io.File dstPath,
                             SVNRevision pegRevision,
                             SVNRevision revision,
                             java.lang.String eolStyle,
                             boolean overwrite,
                             SVNDepth depth)
                      throws SVNException
        Exports the contents of a subversion repository into a 'clean' directory (meaning a directory with no administrative directories).

        pegRevision is the revision where the path is first looked up. If pegRevision is SVNRevision.UNDEFINED, then it defaults to SVNRevision.HEAD.

        If externals are ignored, doesn't process externals definitions as part of this operation.

        eolStyle allows you to override the standard eol marker on the platform you are running on. Can be either "LF", "CR" or "CRLF" or null. If null will use the standard eol marker. Any other value will cause an exception with the error code SVNErrorCode.IO_UNKNOWN_EOL error to be returned.

        If depth is SVNDepth.INFINITY, exports fully recursively. Else if it is SVNDepth.IMMEDIATES, exports url and its immediate children (if any), but with subdirectories empty and atSVNDepth.EMPTY. Else if SVNDepth.FILES, exports url and its immediate file children (if any) only. If depth is SVNDepth.EMPTY, then exports exactly url and none of its children.

        Parameters:
        url - repository url to export from
        dstPath - path to export to
        pegRevision - the revision at which url will be firstly seen in the repository to make sure it's the one that is needed
        revision - the desired revision of the directory/file to be exported
        eolStyle - a string that denotes a specific End-Of-Line character
        overwrite - if true, will cause the export to overwrite files or directories
        depth - tree depth
        Returns:
        value of the revision actually exported
        Throws:
        SVNException
        Since:
        1.2, SVN 1.5
      • doExport

        public long doExport​(java.io.File srcPath,
                             java.io.File dstPath,
                             SVNRevision pegRevision,
                             SVNRevision revision,
                             java.lang.String eolStyle,
                             boolean force,
                             boolean recursive)
                      throws SVNException
        Exports a clean directory or single file from eihter a source Working Copy or a repository.

        How this method works:

        • If revision is different from BASE, WORKING, COMMITTED, UNDEFINED - then the repository origin of srcPath will be exported (what is done by "remote" doExport()).
        • In other cases a clean unversioned copy of srcPath - either a directory or a single file - is exported to dstPath.

        If eolStyle is not null then it should denote a specific End-Of-Line marker for the files to be exported. Significant values for eolStyle are:

        • "CRLF" (Carriage Return Line Feed) - this causes files to contain '\r\n' line ending sequences for EOL markers, regardless of the operating system in use (for instance, this EOL marker is used by software on the Windows platform).
        • "LF" (Line Feed) - this causes files to contain '\n' line ending sequences for EOL markers, regardless of the operating system in use (for instance, this EOL marker is used by software on the Unix platform).
        • "CR" (Carriage Return) - this causes files to contain '\r' line ending sequences for EOL markers, regardless of the operating system in use (for instance, this EOL marker was used by software on older Macintosh platforms).
        • "native" - this causes files to contain the EOL markers that are native to the operating system on which SVNKit is run.
        Parameters:
        srcPath - a repository location from where the unversioned directory/file will be exported
        dstPath - the local path where the repository items will be exported to
        pegRevision - the revision at which url will be firstly seen in the repository to make sure it's the one that is needed
        revision - the desired revision of the directory/file to be exported
        eolStyle - a string that denotes a specific End-Of-Line character;
        force - true to fore the operation even if there are local files with the same names as those in the repository (local ones will be replaced)
        recursive - if true and url is a directory then the entire tree will be exported, otherwise if false - only items located immediately in the directory itself
        Returns:
        the revision number of the exported directory/file
        Throws:
        SVNException
      • doExport

        public long doExport​(java.io.File srcPath,
                             java.io.File dstPath,
                             SVNRevision pegRevision,
                             SVNRevision revision,
                             java.lang.String eolStyle,
                             boolean overwrite,
                             SVNDepth depth)
                      throws SVNException
        Exports the contents of either a subversion repository or a subversion working copy into a 'clean' directory (meaning a directory with no administrative directories).

        pegRevision is the revision where the path is first looked up when exporting from a repository. If pegRevision is SVNRevision.UNDEFINED, then it defaults to SVNRevision.WORKING.

        If revision is one of:

        then local export is performed. Otherwise exporting from the repository.

        If externals are ignored, doesn't process externals definitions as part of this operation.

        eolStyle allows you to override the standard eol marker on the platform you are running on. Can be either "LF", "CR" or "CRLF" or null. If null will use the standard eol marker. Any other value will cause an exception with the error code SVNErrorCode.IO_UNKNOWN_EOL error to be returned.

        If depth is SVNDepth.INFINITY, exports fully recursively. Else if it is SVNDepth.IMMEDIATES, exports srcPath and its immediate children (if any), but with subdirectories empty and atSVNDepth.EMPTY. Else if SVNDepth.FILES, exports srcPath and its immediate file children (if any) only. If depth is SVNDepth.EMPTY, then exports exactly srcPath and none of its children.

        Parameters:
        srcPath - working copy path
        dstPath - path to export to
        pegRevision - the revision at which url will be firstly seen in the repository to make sure it's the one that is needed
        revision - the desired revision of the directory/file to be exported; used only when exporting from a repository
        eolStyle - a string that denotes a specific End-Of-Line character
        overwrite - if true, will cause the export to overwrite files or directories
        depth - tree depth
        Returns:
        value of the revision actually exported
        Throws:
        SVNException
        Since:
        1.2, SVN 1.5
      • doRelocate

        public void doRelocate​(java.io.File dst,
                               SVNURL oldURL,
                               SVNURL newURL,
                               boolean recursive)
                        throws SVNException
        Substitutes the beginning part of a Working Copy's URL with a new one.

        When a repository root location or a URL schema is changed the old URL of the Working Copy which starts with oldURL should be substituted for a new URL beginning - newURL.

        Parameters:
        dst - a Working Copy item's path
        oldURL - the old beginning part of the repository's URL that should be overwritten
        newURL - a new beginning part for the repository location that will overwrite oldURL
        recursive - if true and dst is a directory then the entire tree will be relocated, otherwise if false - only dst itself
        Throws:
        SVNException
      • doCanonicalizeURLs

        public void doCanonicalizeURLs​(java.io.File dst,
                                       boolean omitDefaultPort,
                                       boolean recursive)
                                throws SVNException
        Canonicalizes all urls in the specified Working Copy.
        Parameters:
        dst - a WC path
        omitDefaultPort - if true then removes all port numbers from urls which equal to default ones, otherwise does not
        recursive - recurses an operation
        Throws:
        SVNException
      • setExportExpandsKeywords

        public void setExportExpandsKeywords​(boolean expand)
        Sets whether keywords must be expanded during an export operation.
        Parameters:
        expand - true to expand; otherwise false
        Since:
        1.3
      • isExportExpandsKeywords

        public boolean isExportExpandsKeywords()
        Says whether keywords expansion during export operations is turned on or not.
        Returns:
        true if expanding keywords; false otherwise
        Since:
        1.3
      • copyVersionedDir

        private void copyVersionedDir​(java.io.File from,
                                      java.io.File to,
                                      SVNRevision revision,
                                      java.lang.String eolStyle,
                                      boolean force,
                                      SVNDepth depth)
                               throws SVNException
        Throws:
        SVNException
      • canonicalizeExtenrals

        public static java.lang.String canonicalizeExtenrals​(java.lang.String externals,
                                                             boolean omitDefaultPort)
                                                      throws SVNException
        Throws:
        SVNException
      • handleExternals

        private void handleExternals​(SVNWCAccess wcAccess,
                                     java.io.File root,
                                     java.util.Map oldExternals,
                                     java.util.Map newExternals,
                                     java.util.Map depths,
                                     SVNURL fromURL,
                                     SVNURL rootURL,
                                     SVNDepth requestedDepth,
                                     boolean isExport,
                                     boolean updateUnchanged)
                              throws SVNException
        Throws:
        SVNException
      • getOwnerURL

        private SVNURL getOwnerURL​(java.io.File root)
      • handleExternalChange

        private void handleExternalChange​(SVNWCAccess access,
                                          java.lang.String targetDir,
                                          SVNUpdateClient16.ExternalDiff externalDiff)
                                   throws SVNException
        oldURL is null when externals is added: jsvn ps svn:externals "path URL" . jsvn up . newURL is null when external is deleted: jsvn pd svn:externals . jsvn up . Also newURL or oldURL could be null, when external property is added or removed by update itself (someone else has changed it). For instance, oldURL is always null during checkout or export operation.
        Throws:
        SVNException
      • validateRelocateTargetURL

        private java.util.Map validateRelocateTargetURL​(SVNURL targetURL,
                                                        java.lang.String expectedUUID,
                                                        java.util.Map validatedURLs,
                                                        boolean isRoot)
                                                 throws SVNException
        Throws:
        SVNException
      • relocateEntry

        private java.util.Map relocateEntry​(SVNEntry entry,
                                            java.lang.String from,
                                            java.lang.String to,
                                            java.util.Map validatedURLs)
                                     throws SVNException
        Throws:
        SVNException
      • doRelocate

        private java.util.Map doRelocate​(SVNAdminArea adminArea,
                                         java.lang.String name,
                                         java.lang.String from,
                                         java.lang.String to,
                                         boolean recursive,
                                         java.util.Map validatedURLs)
                                  throws SVNException
        Throws:
        SVNException