| /** |
| * @copyright |
| * ==================================================================== |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * ==================================================================== |
| * @endcopyright |
| * |
| * @file svn_wc.h |
| * @brief Subversion's working copy library |
| * |
| * Requires: |
| * - A working copy |
| * |
| * Provides: |
| * - Ability to manipulate working copy's versioned data. |
| * - Ability to manipulate working copy's administrative files. |
| * |
| * Used By: |
| * - Clients. |
| * |
| * Notes: |
| * The 'path' parameters to most of the older functions can be |
| * absolute or relative (relative to current working |
| * directory). If there are any cases where they are |
| * relative to the path associated with the |
| * 'svn_wc_adm_access_t *adm_access' baton passed along with the |
| * path, those cases should be explicitly documented, and if they |
| * are not, please fix it. All new functions introduced since |
| * Subversion 1.7 require absolute paths, unless explicitly |
| * documented otherwise. |
| * |
| * Starting with Subversion 1.7, several arguments are re-ordered |
| * to be more consistent through the api. The common ordering used |
| * is: |
| * |
| * Firsts: |
| * - Output arguments |
| * Then: |
| * - Working copy context |
| * - Local abspath |
| * Followed by: |
| * - Function specific arguments |
| * - Specific callbacks with their batons |
| * Finally: |
| * - Generic callbacks (with baton) from directly functional to |
| * just observing: |
| * - svn_wc_conflict_resolver_func2_t |
| * - svn_wc_external_update_t |
| * - svn_cancel_func_t |
| * - svn_wc_notify_func2_t |
| * - Result pool |
| * - Scratch pool. |
| */ |
| |
| #ifndef SVN_WC_H |
| #define SVN_WC_H |
| |
| #include <apr.h> |
| #include <apr_pools.h> |
| #include <apr_tables.h> |
| #include <apr_hash.h> |
| #include <apr_time.h> |
| #include <apr_file_io.h> |
| |
| #include "svn_types.h" |
| #include "svn_string.h" |
| #include "svn_checksum.h" |
| #include "svn_io.h" |
| #include "svn_delta.h" /* for svn_stream_t */ |
| #include "svn_opt.h" |
| #include "svn_ra.h" /* for svn_ra_reporter_t type */ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif /* __cplusplus */ |
| |
| |
| /** |
| * Get libsvn_wc version information. |
| * |
| * @since New in 1.1. |
| */ |
| const svn_version_t * |
| svn_wc_version(void); |
| |
| |
| /** |
| * @defgroup svn_wc Working copy management |
| * @{ |
| */ |
| |
| |
| /** Flags for use with svn_wc_translated_file2() and svn_wc_translated_stream(). |
| * |
| * @defgroup translate_flags Translation flags |
| * @{ |
| */ |
| |
| /** Translate from Normal Form. |
| * |
| * The working copy text bases and repository files are stored |
| * in normal form. Some files' contents - or ever representation - |
| * differs between the working copy and the normal form. This flag |
| * specifies to take the latter form as input and transform it |
| * to the former. |
| * |
| * Either this flag or #SVN_WC_TRANSLATE_TO_NF should be specified, |
| * but not both. |
| */ |
| #define SVN_WC_TRANSLATE_FROM_NF 0x00000000 |
| |
| /** Translate to Normal Form. |
| * |
| * Either this flag or #SVN_WC_TRANSLATE_FROM_NF should be specified, |
| * but not both. |
| */ |
| #define SVN_WC_TRANSLATE_TO_NF 0x00000001 |
| |
| /** Force repair of eol styles, making sure the output file consistently |
| * contains the one eol style as specified by the svn:eol-style |
| * property and the required translation direction. |
| * |
| */ |
| #define SVN_WC_TRANSLATE_FORCE_EOL_REPAIR 0x00000002 |
| |
| /** Don't register a pool cleanup to delete the output file */ |
| #define SVN_WC_TRANSLATE_NO_OUTPUT_CLEANUP 0x00000004 |
| |
| /** Guarantee a new file is created on successful return. |
| * The default shortcuts translation by returning the path |
| * of the untranslated file when no translation is required. |
| */ |
| #define SVN_WC_TRANSLATE_FORCE_COPY 0x00000008 |
| |
| /** Use a non-wc-local tmp directory for creating output files, |
| * instead of in the working copy admin tmp area which is the default. |
| * |
| * @since New in 1.4. |
| */ |
| #define SVN_WC_TRANSLATE_USE_GLOBAL_TMP 0x00000010 |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup svn_wc_context Working copy context |
| * @{ |
| */ |
| |
| /** The context for all working copy interactions. |
| * |
| * This is the client-facing datastructure API consumers are required |
| * to create and use when interacting with a working copy. Multiple |
| * contexts can be created for the same working copy simultaneously, within |
| * the same process or different processes. Context mutexing will be handled |
| * internally by the working copy library. |
| * |
| * @note: #svn_wc_context_t should be passed by non-const pointer in all |
| * APIs, even for read-only operations, as it contains mutable data (caching, |
| * etc.). |
| * |
| * @since New in 1.7. |
| */ |
| typedef struct svn_wc_context_t svn_wc_context_t; |
| |
| /** Create a context for the working copy, and return it in @a *wc_ctx. This |
| * context is not associated with a particular working copy, but as operations |
| * are performed, will load the appropriate working copy information. |
| * |
| * @a config should hold the various configuration options that may apply to |
| * this context. It should live at least as long as @a result_pool. It may |
| * be @c NULL. |
| * |
| * The context will be allocated in @a result_pool, and will use @a |
| * result_pool for any internal allocations requiring the same longevity as |
| * the context. The context will be automatically destroyed, and its |
| * resources released, when @a result_pool is cleared, or it may be manually |
| * destroyed by invoking svn_wc_context_destroy(). |
| * |
| * Use @a scratch_pool for temporary allocations. It may be cleared |
| * immediately upon returning from this function. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_context_create(svn_wc_context_t **wc_ctx, |
| const svn_config_t *config, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Destroy the working copy context described by @a wc_ctx, releasing any |
| * acquired resources. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_context_destroy(svn_wc_context_t *wc_ctx); |
| |
| |
| /** @} */ |
| |
| |
| /** |
| * Locking/Opening/Closing using adm access batons. |
| * |
| * @defgroup svn_wc_adm_access Adm access batons (deprecated) |
| * @{ |
| */ |
| |
| /** Baton for access to a working copy administrative area. |
| * |
| * Access batons can be grouped into sets, by passing an existing open |
| * baton when opening a new baton. Given one baton in a set, other batons |
| * may be retrieved. This allows an entire hierarchy to be locked, and |
| * then the set of batons can be passed around by passing a single baton. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| * New code should use a #svn_wc_context_t object to access the working |
| * copy. |
| */ |
| typedef struct svn_wc_adm_access_t svn_wc_adm_access_t; |
| |
| |
| /** |
| * Return, in @a *adm_access, a pointer to a new access baton for the working |
| * copy administrative area associated with the directory @a path. If |
| * @a write_lock is TRUE the baton will include a write lock, otherwise the |
| * baton can only be used for read access. If @a path refers to a directory |
| * that is already write locked then the error #SVN_ERR_WC_LOCKED will be |
| * returned. The error #SVN_ERR_WC_NOT_DIRECTORY will be returned if |
| * @a path is not a versioned directory. |
| * |
| * If @a associated is an open access baton then @a adm_access will be added |
| * to the set containing @a associated. @a associated can be @c NULL, in |
| * which case @a adm_access is the start of a new set. |
| * |
| * @a levels_to_lock specifies how far to lock. Zero means just the specified |
| * directory. Any negative value means to lock the entire working copy |
| * directory hierarchy under @a path. A positive value indicates the number of |
| * levels of directories to lock -- 1 means just immediate subdirectories, 2 |
| * means immediate subdirectories and their subdirectories, etc. All the |
| * access batons will become part of the set containing @a adm_access. This |
| * is an all-or-nothing option, if it is not possible to lock all the |
| * requested directories then an error will be returned and @a adm_access will |
| * be invalid, with the exception that subdirectories of @a path that are |
| * missing from the physical filesystem will not be locked and will not cause |
| * an error. The error #SVN_ERR_WC_LOCKED will be returned if a |
| * subdirectory of @a path is already write locked. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine |
| * if the client has canceled the operation. |
| * |
| * @a pool will be used to allocate memory for the baton and any subsequently |
| * cached items. If @a adm_access has not been closed when the pool is |
| * cleared, it will be closed automatically at that point, and removed from |
| * its set. A baton closed in this way will not remove physical locks from |
| * the working copy if cleanup is required. |
| * |
| * The first baton in a set, with @a associated passed as @c NULL, must have |
| * the longest lifetime of all the batons in the set. This implies it must be |
| * the root of the hierarchy. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| * Callers should use a #svn_wc_context_t object to access the working |
| * copy. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_open3(svn_wc_adm_access_t **adm_access, |
| svn_wc_adm_access_t *associated, |
| const char *path, |
| svn_boolean_t write_lock, |
| int levels_to_lock, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_adm_open3(), but without cancellation support. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_open2(svn_wc_adm_access_t **adm_access, |
| svn_wc_adm_access_t *associated, |
| const char *path, |
| svn_boolean_t write_lock, |
| int levels_to_lock, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_adm_open2(), but with @a tree_lock instead of |
| * @a levels_to_lock. @a levels_to_lock is set to -1 if @a tree_lock |
| * is @c TRUE, else 0. |
| * |
| * @deprecated Provided for backward compatibility with the 1.0 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_open(svn_wc_adm_access_t **adm_access, |
| svn_wc_adm_access_t *associated, |
| const char *path, |
| svn_boolean_t write_lock, |
| svn_boolean_t tree_lock, |
| apr_pool_t *pool); |
| |
| /** |
| * Checks the working copy to determine the node type of @a path. If |
| * @a path is a versioned directory then the behaviour is like that of |
| * svn_wc_adm_open3(), otherwise, if @a path is a file or does not |
| * exist, then the behaviour is like that of svn_wc_adm_open3() with |
| * @a path replaced by the parent directory of @a path. If @a path is |
| * an unversioned directory, the behaviour is also like that of |
| * svn_wc_adm_open3() on the parent, except that if the open fails, |
| * then the returned #SVN_ERR_WC_NOT_DIRECTORY error refers to @a path, |
| * not to @a path's parent. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| * Callers should use a #svn_wc_context_t object to access the working |
| * copy. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_probe_open3(svn_wc_adm_access_t **adm_access, |
| svn_wc_adm_access_t *associated, |
| const char *path, |
| svn_boolean_t write_lock, |
| int levels_to_lock, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_adm_probe_open3() without the cancel |
| * functionality. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_probe_open2(svn_wc_adm_access_t **adm_access, |
| svn_wc_adm_access_t *associated, |
| const char *path, |
| svn_boolean_t write_lock, |
| int levels_to_lock, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_adm_probe_open2(), but with @a tree_lock instead of |
| * @a levels_to_lock. @a levels_to_lock is set to -1 if @a tree_lock |
| * is @c TRUE, else 0. |
| * |
| * @deprecated Provided for backward compatibility with the 1.0 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_probe_open(svn_wc_adm_access_t **adm_access, |
| svn_wc_adm_access_t *associated, |
| const char *path, |
| svn_boolean_t write_lock, |
| svn_boolean_t tree_lock, |
| apr_pool_t *pool); |
| |
| /** |
| * Open access batons for @a path and return in @a *anchor_access and |
| * @a *target the anchor and target required to drive an editor. Return |
| * in @a *target_access the access baton for the target, which may be the |
| * same as @a *anchor_access (in which case @a *target is the empty |
| * string, never NULL). All the access batons will be in the |
| * @a *anchor_access set. |
| * |
| * @a levels_to_lock determines the levels_to_lock used when opening |
| * @a path if @a path is a versioned directory, @a levels_to_lock is |
| * ignored otherwise. If @a write_lock is @c TRUE the access batons |
| * will hold write locks. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine |
| * if the client has canceled the operation. |
| * |
| * This function is essentially a combination of svn_wc_adm_open3() and |
| * svn_wc_get_actual_target(), with the emphasis on reducing physical IO. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| * Callers should use a #svn_wc_context_t object to access the working |
| * copy. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_open_anchor(svn_wc_adm_access_t **anchor_access, |
| svn_wc_adm_access_t **target_access, |
| const char **target, |
| const char *path, |
| svn_boolean_t write_lock, |
| int levels_to_lock, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| /** Return, in @a *adm_access, a pointer to an existing access baton associated |
| * with @a path. @a path must be a directory that is locked as part of the |
| * set containing the @a associated access baton. |
| * |
| * If the requested access baton is marked as missing in, or is simply |
| * absent from, @a associated, return #SVN_ERR_WC_NOT_LOCKED. |
| * |
| * @a pool is used only for local processing, it is not used for the batons. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_retrieve(svn_wc_adm_access_t **adm_access, |
| svn_wc_adm_access_t *associated, |
| const char *path, |
| apr_pool_t *pool); |
| |
| /** Check the working copy to determine the node type of @a path. If |
| * @a path is a versioned directory then the behaviour is like that of |
| * svn_wc_adm_retrieve(), otherwise, if @a path is a file, an unversioned |
| * directory, or does not exist, then the behaviour is like that of |
| * svn_wc_adm_retrieve() with @a path replaced by the parent directory of |
| * @a path. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_probe_retrieve(svn_wc_adm_access_t **adm_access, |
| svn_wc_adm_access_t *associated, |
| const char *path, |
| apr_pool_t *pool); |
| |
| /** |
| * Try various ways to obtain an access baton for @a path. |
| * |
| * First, try to obtain @a *adm_access via svn_wc_adm_probe_retrieve(), |
| * but if this fails because @a associated can't give a baton for |
| * @a path or @a path's parent, then try svn_wc_adm_probe_open3(), |
| * this time passing @a write_lock and @a levels_to_lock. If there is |
| * still no access because @a path is not a versioned directory, then |
| * just set @a *adm_access to NULL and return success. But if it is |
| * because @a path is locked, then return the error #SVN_ERR_WC_LOCKED, |
| * and the effect on @a *adm_access is undefined. (Or if the attempt |
| * fails for any other reason, return the corresponding error, and the |
| * effect on @a *adm_access is also undefined.) |
| * |
| * If svn_wc_adm_probe_open3() succeeds, then add @a *adm_access to |
| * @a associated. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine |
| * if the client has canceled the operation. |
| * |
| * Use @a pool only for local processing, not to allocate @a *adm_access. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_probe_try3(svn_wc_adm_access_t **adm_access, |
| svn_wc_adm_access_t *associated, |
| const char *path, |
| svn_boolean_t write_lock, |
| int levels_to_lock, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_adm_probe_try3() without the cancel |
| * functionality. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_probe_try2(svn_wc_adm_access_t **adm_access, |
| svn_wc_adm_access_t *associated, |
| const char *path, |
| svn_boolean_t write_lock, |
| int levels_to_lock, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_adm_probe_try2(), but with @a tree_lock instead of |
| * @a levels_to_lock. @a levels_to_lock is set to -1 if @a tree_lock |
| * is @c TRUE, else 0. |
| * |
| * @deprecated Provided for backward compatibility with the 1.0 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_probe_try(svn_wc_adm_access_t **adm_access, |
| svn_wc_adm_access_t *associated, |
| const char *path, |
| svn_boolean_t write_lock, |
| svn_boolean_t tree_lock, |
| apr_pool_t *pool); |
| |
| |
| /** Give up the access baton @a adm_access, and its lock if any. This will |
| * recursively close any batons in the same set that are direct |
| * subdirectories of @a adm_access. Any physical locks will be removed from |
| * the working copy. Lock removal is unconditional, there is no check to |
| * determine if cleanup is required. |
| * |
| * Any temporary allocations are performed using @a scratch_pool. |
| * |
| * @since New in 1.6 |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_close2(svn_wc_adm_access_t *adm_access, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_adm_close2(), but with the internal pool of @a adm_access |
| * used for temporary allocations. |
| * |
| * @deprecated Provided for backward compatibility with the 1.5 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_adm_close(svn_wc_adm_access_t *adm_access); |
| |
| /** Return the path used to open the access baton @a adm_access. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| const char * |
| svn_wc_adm_access_path(const svn_wc_adm_access_t *adm_access); |
| |
| /** Return the pool used by access baton @a adm_access. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| apr_pool_t * |
| svn_wc_adm_access_pool(const svn_wc_adm_access_t *adm_access); |
| |
| /** Return @c TRUE is the access baton @a adm_access has a write lock, |
| * @c FALSE otherwise. Compared to svn_wc_locked() this is a cheap, fast |
| * function that doesn't access the filesystem. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| * New code should use svn_wc_locked2() instead. |
| */ |
| SVN_DEPRECATED |
| svn_boolean_t |
| svn_wc_adm_locked(const svn_wc_adm_access_t *adm_access); |
| |
| /** @} */ |
| |
| |
| /** Gets up to two booleans indicating whether a path is locked for |
| * writing. |
| * |
| * @a locked_here is set to TRUE when a write lock on @a local_abspath |
| * exists in @a wc_ctx. @a locked is set to TRUE when there is a |
| * write_lock on @a local_abspath |
| * |
| * @a locked_here and/or @a locked can be NULL when you are not |
| * interested in a specific value |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_locked2(svn_boolean_t *locked_here, |
| svn_boolean_t *locked, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *scratch_pool); |
| |
| /** Set @a *locked to non-zero if @a path is locked, else set it to zero. |
| * |
| * New code should use svn_wc_locked2() instead. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_locked(svn_boolean_t *locked, |
| const char *path, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * @defgroup svn_wc_adm_dir_name Name of Subversion's admin dir |
| * @{ |
| */ |
| |
| /** The default name of the administrative subdirectory. |
| * |
| * Ideally, this would be completely private to wc internals (in fact, |
| * it used to be that adm_subdir() in adm_files.c was the only function |
| * who knew the adm subdir's name). However, import wants to protect |
| * against importing administrative subdirs, so now the name is a |
| * matter of public record. |
| * |
| * @deprecated Provided for backward compatibility with the 1.2 API. |
| */ |
| #define SVN_WC_ADM_DIR_NAME ".svn" |
| |
| |
| /** |
| * Return @c TRUE if @a name is the name of the WC administrative |
| * directory. Use @a pool for any temporary allocations. Only works |
| * with base directory names, not paths or URIs. |
| * |
| * For compatibility, the default name (.svn) will always be treated |
| * as an admin dir name, even if the working copy is actually using an |
| * alternative name. |
| * |
| * @since New in 1.3. |
| */ |
| svn_boolean_t |
| svn_wc_is_adm_dir(const char *name, apr_pool_t *pool); |
| |
| |
| /** |
| * Return the name of the administrative directory. |
| * Use @a pool for any temporary allocations. |
| * |
| * The returned pointer will refer to either a statically allocated |
| * string, or to a string allocated in @a pool. |
| * |
| * @since New in 1.3. |
| */ |
| const char * |
| svn_wc_get_adm_dir(apr_pool_t *pool); |
| |
| |
| /** |
| * Use @a name for the administrative directory in the working copy. |
| * Use @a pool for any temporary allocations. |
| * |
| * The list of valid names is limited. Currently only ".svn" (the |
| * default) and "_svn" are allowed. |
| * |
| * @note This function changes global (per-process) state and must be |
| * called in a single-threaded context during the initialization of a |
| * Subversion client. |
| * |
| * @since New in 1.3. |
| */ |
| svn_error_t * |
| svn_wc_set_adm_dir(const char *name, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup svn_wc_externals Externals |
| * @{ |
| */ |
| |
| /** Callback for external definitions updates |
| * |
| * @a local_abspath is the path on which the external definition was found. |
| * @a old_val and @a new_val are the before and after values of the |
| * SVN_PROP_EXTERNALS property. @a depth is the ambient depth of the |
| * working copy directory at @a local_abspath. |
| * |
| * @since New in 1.7. */ |
| typedef svn_error_t *(*svn_wc_external_update_t)(void *baton, |
| const char *local_abspath, |
| const svn_string_t *old_val, |
| const svn_string_t *new_val, |
| svn_depth_t depth, |
| apr_pool_t *scratch_pool); |
| |
| /** Traversal information is information gathered by a working copy |
| * crawl or update. For example, the before and after values of the |
| * svn:externals property are important after an update, and since |
| * we're traversing the working tree anyway (a complete traversal |
| * during the initial crawl, and a traversal of changed paths during |
| * the checkout/update/switch), it makes sense to gather the |
| * property's values then instead of making a second pass. |
| * |
| * New code should use the svn_wc_external_update_t callback instead. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| typedef struct svn_wc_traversal_info_t svn_wc_traversal_info_t; |
| |
| |
| /** Return a new, empty traversal info object, allocated in @a pool. |
| * |
| * New code should use the svn_wc_external_update_t callback instead. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_wc_traversal_info_t * |
| svn_wc_init_traversal_info(apr_pool_t *pool); |
| |
| /** Set @a *externals_old and @a *externals_new to hash tables representing |
| * changes to values of the svn:externals property on directories |
| * traversed by @a traversal_info. |
| * |
| * @a traversal_info is obtained from svn_wc_init_traversal_info(), but is |
| * only useful after it has been passed through another function, such |
| * as svn_wc_crawl_revisions(), svn_wc_get_update_editor(), |
| * svn_wc_get_switch_editor(), etc. |
| * |
| * Each hash maps <tt>const char *</tt> directory names onto |
| * <tt>const char *</tt> values of the externals property for that directory. |
| * The dir names are full paths -- that is, anchor plus target, not target |
| * alone. The values are not parsed, they are simply copied raw, and are |
| * never NULL: directories that acquired or lost the property are |
| * simply omitted from the appropriate table. Directories whose value |
| * of the property did not change show the same value in each hash. |
| * |
| * The hashes, keys, and values have the same lifetime as @a traversal_info. |
| * |
| * New code should use the svn_wc_external_update_t callback instead. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| void |
| svn_wc_edited_externals(apr_hash_t **externals_old, |
| apr_hash_t **externals_new, |
| svn_wc_traversal_info_t *traversal_info); |
| |
| |
| /** Set @a *depths to a hash table mapping <tt>const char *</tt> |
| * directory names (directories traversed by @a traversal_info) to |
| * <tt>const char *</tt> values (the depths of those directories, as |
| * converted by svn_depth_to_word()). |
| * |
| * @a traversal_info is obtained from svn_wc_init_traversal_info(), but is |
| * only useful after it has been passed through another function, such |
| * as svn_wc_crawl_revisions(), svn_wc_get_update_editor(), |
| * svn_wc_get_switch_editor(), etc. |
| * |
| * The dir names are full paths -- that is, anchor plus target, not target |
| * alone. The values are not allocated, they are static constant strings. |
| * Although the values are never NULL, not all directories traversed |
| * are necessarily listed. For example, directories which did not |
| * have an svn:externals property set or modified are not included. |
| * |
| * The hashes and keys have the same lifetime as @a traversal_info. |
| * |
| * New code should use the svn_wc_external_update_t callback instead. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| void |
| svn_wc_traversed_depths(apr_hash_t **depths, |
| svn_wc_traversal_info_t *traversal_info); |
| |
| |
| /** One external item. This usually represents one line from an |
| * svn:externals description but with the path and URL |
| * canonicalized. |
| * |
| * In order to avoid backwards compatibility problems clients should use |
| * svn_wc_external_item2_create() to allocate and initialize this structure |
| * instead of doing so themselves. |
| * |
| * @since New in 1.5. |
| */ |
| typedef struct svn_wc_external_item2_t |
| { |
| /** The name of the subdirectory into which this external should be |
| checked out. This is relative to the parent directory that |
| holds this external item. (Note that these structs are often |
| stored in hash tables with the target dirs as keys, so this |
| field will often be redundant.) */ |
| const char *target_dir; |
| |
| /** Where to check out from. This is possibly a relative external URL, as |
| * allowed in externals definitions, but without the peg revision. */ |
| const char *url; |
| |
| /** What revision to check out. The only valid kinds for this are |
| svn_opt_revision_number, svn_opt_revision_date, and |
| svn_opt_revision_head. */ |
| svn_opt_revision_t revision; |
| |
| /** The peg revision to use when checking out. The only valid kinds are |
| svn_opt_revision_number, svn_opt_revision_date, and |
| svn_opt_revision_head. */ |
| svn_opt_revision_t peg_revision; |
| |
| } svn_wc_external_item2_t; |
| |
| /** |
| * Initialize an external item. |
| * Set @a *item to an external item object, allocated in @a pool. |
| * |
| * In order to avoid backwards compatibility problems, this function |
| * is used to initialize and allocate the #svn_wc_external_item2_t |
| * structure rather than doing so explicitly, as the size of this |
| * structure may change in the future. |
| * |
| * The current implementation never returns error, but callers should |
| * still check for error, for compatibility with future versions. |
| * |
| * @since New in 1.8. |
| */ |
| svn_error_t * |
| svn_wc_external_item2_create(svn_wc_external_item2_t **item, |
| apr_pool_t *pool); |
| |
| /** Same as svn_wc_external_item2_create() except the pointer to the new |
| * empty item is 'const' which is stupid since the next thing you need to do |
| * is fill in its fields. |
| * |
| * @deprecated Provided for backward compatibility with the 1.7 API. |
| * @since New in 1.5. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_external_item_create(const svn_wc_external_item2_t **item, |
| apr_pool_t *pool); |
| |
| /** |
| * Return a duplicate of @a item, allocated in @a pool. No part of the new |
| * item will be shared with @a item. |
| * |
| * @since New in 1.5. |
| */ |
| svn_wc_external_item2_t * |
| svn_wc_external_item2_dup(const svn_wc_external_item2_t *item, |
| apr_pool_t *pool); |
| |
| /** |
| * One external item. Similar to svn_wc_external_item2_t, except |
| * @a revision is interpreted as both the operational revision and the |
| * peg revision. |
| * |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| */ |
| typedef struct svn_wc_external_item_t |
| { |
| /** Same as #svn_wc_external_item2_t.target_dir */ |
| const char *target_dir; |
| |
| /** Same as #svn_wc_external_item2_t.url */ |
| const char *url; |
| |
| /** Same as #svn_wc_external_item2_t.revision */ |
| svn_opt_revision_t revision; |
| |
| } svn_wc_external_item_t; |
| |
| /** |
| * Return a duplicate of @a item, allocated in @a pool. No part of the new |
| * item will be shared with @a item. |
| * |
| * @since New in 1.3. |
| * |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_wc_external_item_t * |
| svn_wc_external_item_dup(const svn_wc_external_item_t *item, |
| apr_pool_t *pool); |
| |
| /** |
| * If @a externals_p is non-NULL, set @a *externals_p to an array of |
| * #svn_wc_external_item2_t * objects based on @a desc. |
| * |
| * If the format of @a desc is invalid, don't touch @a *externals_p and |
| * return #SVN_ERR_CLIENT_INVALID_EXTERNALS_DESCRIPTION. Thus, if |
| * you just want to check the validity of an externals description, |
| * and don't care about the parsed result, pass NULL for @a externals_p. |
| * |
| * The format of @a desc is the same as for values of the directory |
| * property #SVN_PROP_EXTERNALS. Look there for more details. |
| * |
| * If @a canonicalize_url is @c TRUE, canonicalize the @a url member |
| * of those objects. If the @a url member refers to an absolute URL, |
| * it will be canonicalized as URL consistent with the way URLs are |
| * canonicalized throughout the Subversion API. If, however, the |
| * @a url member makes use of the recognized (SVN-specific) relative |
| * URL syntax for svn:externals, "canonicalization" is an ill-defined |
| * concept which may even result in munging the relative URL syntax |
| * beyond recognition. You've been warned. |
| * |
| * Allocate the table, keys, and values in @a pool. |
| * |
| * @a defining_directory is the path or URL of the directory on which |
| * the svn:externals property corresponding to @a desc is set. |
| * @a defining_directory is only used when constructing error strings. |
| * |
| * @since New in 1.5. |
| */ |
| svn_error_t * |
| svn_wc_parse_externals_description3(apr_array_header_t **externals_p, |
| const char *defining_directory, |
| const char *desc, |
| svn_boolean_t canonicalize_url, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_parse_externals_description3() with @a |
| * canonicalize_url set to @c TRUE, but returns an array of |
| * #svn_wc_external_item_t * objects instead of |
| * #svn_wc_external_item2_t * objects |
| * |
| * @since New in 1.1. |
| * |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_parse_externals_description2(apr_array_header_t **externals_p, |
| const char *parent_directory, |
| const char *desc, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_parse_externals_description2(), but returns the |
| * parsed externals in a hash instead of an array. This function |
| * should not be used, as storing the externals in a hash causes their |
| * order of evaluation to be not easily identifiable. |
| * |
| * @deprecated Provided for backward compatibility with the 1.0 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_parse_externals_description(apr_hash_t **externals_p, |
| const char *parent_directory, |
| const char *desc, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup svn_wc_notifications Notification callback handling |
| * @{ |
| * |
| * In many cases, the WC library will scan a working copy and make |
| * changes. The caller usually wants to know when each of these changes |
| * has been made, so that it can display some kind of notification to |
| * the user. |
| * |
| * These notifications have a standard callback function type, which |
| * takes the path of the file that was affected, and a caller- |
| * supplied baton. |
| * |
| * @note The callback is a 'void' return -- this is a simple |
| * reporting mechanism, rather than an opportunity for the caller to |
| * alter the operation of the WC library. |
| * |
| * @note Some of the actions are used across several |
| * different Subversion commands. For example, the update actions are |
| * also used for checkouts, switches, and merges. |
| */ |
| |
| /** The type of action occurring. */ |
| typedef enum svn_wc_notify_action_t |
| { |
| /** Adding a path to revision control. */ |
| svn_wc_notify_add = 0, |
| |
| /** Copying a versioned path. */ |
| svn_wc_notify_copy, |
| |
| /** Deleting a versioned path. */ |
| svn_wc_notify_delete, |
| |
| /** Restoring a missing path from the pristine text-base. */ |
| svn_wc_notify_restore, |
| |
| /** Reverting a modified path. */ |
| svn_wc_notify_revert, |
| |
| /** A revert operation has failed. */ |
| svn_wc_notify_failed_revert, |
| |
| /** All conflicts on a path were marked as resolved. |
| * @note As of 1.10, separate notifications are sent for individually |
| * resolved text, property, and tree conflicts. This notification is used |
| * only if all conflicts on a path were marked resolved at once. */ |
| svn_wc_notify_resolved, |
| |
| /** Skipping a path. */ |
| svn_wc_notify_skip, |
| |
| /** Got a delete in an update. */ |
| svn_wc_notify_update_delete, |
| |
| /** Got an add in an update. */ |
| svn_wc_notify_update_add, |
| |
| /** Got any other action in an update. */ |
| svn_wc_notify_update_update, |
| |
| /** The last notification in an update (including updates of externals). */ |
| svn_wc_notify_update_completed, |
| |
| /** Updating an external module. */ |
| svn_wc_notify_update_external, |
| |
| /** The last notification in a status (including status on externals). */ |
| svn_wc_notify_status_completed, |
| |
| /** Running status on an external module. */ |
| svn_wc_notify_status_external, |
| |
| /** Committing a modification. */ |
| svn_wc_notify_commit_modified, |
| |
| /** Committing an addition. */ |
| svn_wc_notify_commit_added, |
| |
| /** Committing a deletion. */ |
| svn_wc_notify_commit_deleted, |
| |
| /** Committing a replacement. */ |
| svn_wc_notify_commit_replaced, |
| |
| /** Transmitting post-fix text-delta data for a file. */ |
| svn_wc_notify_commit_postfix_txdelta, |
| |
| /** Processed a single revision's blame. */ |
| svn_wc_notify_blame_revision, |
| |
| /** Locking a path. @since New in 1.2. */ |
| svn_wc_notify_locked, |
| |
| /** Unlocking a path. @since New in 1.2. */ |
| svn_wc_notify_unlocked, |
| |
| /** Failed to lock a path. @since New in 1.2. */ |
| svn_wc_notify_failed_lock, |
| |
| /** Failed to unlock a path. @since New in 1.2. */ |
| svn_wc_notify_failed_unlock, |
| |
| /** Tried adding a path that already exists. @since New in 1.5. */ |
| svn_wc_notify_exists, |
| |
| /** Changelist name set. @since New in 1.5. */ |
| svn_wc_notify_changelist_set, |
| |
| /** Changelist name cleared. @since New in 1.5. */ |
| svn_wc_notify_changelist_clear, |
| |
| /** Warn user that a path has moved from one changelist to another. |
| @since New in 1.5. |
| @deprecated As of 1.7, separate clear and set notifications are sent. */ |
| svn_wc_notify_changelist_moved, |
| |
| /** A merge operation (to path) has begun. See #svn_wc_notify_t.merge_range. |
| @since New in 1.5. */ |
| svn_wc_notify_merge_begin, |
| |
| /** A merge operation (to path) from a foreign repository has begun. |
| See #svn_wc_notify_t.merge_range. @since New in 1.5. */ |
| svn_wc_notify_foreign_merge_begin, |
| |
| /** Replace notification. @since New in 1.5. */ |
| svn_wc_notify_update_replace, |
| |
| /** Property added. @since New in 1.6. */ |
| svn_wc_notify_property_added, |
| |
| /** Property updated. @since New in 1.6. */ |
| svn_wc_notify_property_modified, |
| |
| /** Property deleted. @since New in 1.6. */ |
| svn_wc_notify_property_deleted, |
| |
| /** Nonexistent property deleted. @since New in 1.6. */ |
| svn_wc_notify_property_deleted_nonexistent, |
| |
| /** Revprop set. @since New in 1.6. */ |
| svn_wc_notify_revprop_set, |
| |
| /** Revprop deleted. @since New in 1.6. */ |
| svn_wc_notify_revprop_deleted, |
| |
| /** The last notification in a merge. @since New in 1.6. */ |
| svn_wc_notify_merge_completed, |
| |
| /** The path is a tree-conflict victim of the intended action (*not* |
| * a persistent tree-conflict from an earlier operation, but *this* |
| * operation caused the tree-conflict). @since New in 1.6. */ |
| svn_wc_notify_tree_conflict, |
| |
| /** The path is a subdirectory referenced in an externals definition |
| * which is unable to be operated on. @since New in 1.6. */ |
| svn_wc_notify_failed_external, |
| |
| /** Starting an update operation. @since New in 1.7. */ |
| svn_wc_notify_update_started, |
| |
| /** An update tried to add a file or directory at a path where |
| * a separate working copy was found. @since New in 1.7. */ |
| svn_wc_notify_update_skip_obstruction, |
| |
| /** An explicit update tried to update a file or directory that |
| * doesn't live in the repository and can't be brought in. |
| * @since New in 1.7. */ |
| svn_wc_notify_update_skip_working_only, |
| |
| /** An update tried to update a file or directory to which access could |
| * not be obtained. @since New in 1.7. */ |
| svn_wc_notify_update_skip_access_denied, |
| |
| /** An update operation removed an external working copy. |
| * @since New in 1.7. */ |
| svn_wc_notify_update_external_removed, |
| |
| /** A node below an existing node was added during update. |
| * @since New in 1.7. */ |
| svn_wc_notify_update_shadowed_add, |
| |
| /** A node below an existing node was updated during update. |
| * @since New in 1.7. */ |
| svn_wc_notify_update_shadowed_update, |
| |
| /** A node below an existing node was deleted during update. |
| * @since New in 1.7. */ |
| svn_wc_notify_update_shadowed_delete, |
| |
| /** The mergeinfo on path was updated. @since New in 1.7. */ |
| svn_wc_notify_merge_record_info, |
| |
| /** A working copy directory was upgraded to the latest format. |
| * @since New in 1.7. */ |
| svn_wc_notify_upgraded_path, |
| |
| /** Mergeinfo describing a merge was recorded. |
| * @since New in 1.7. */ |
| svn_wc_notify_merge_record_info_begin, |
| |
| /** Mergeinfo was removed due to elision. |
| * @since New in 1.7. */ |
| svn_wc_notify_merge_elide_info, |
| |
| /** A file in the working copy was patched. |
| * @since New in 1.7. */ |
| svn_wc_notify_patch, |
| |
| /** A hunk from a patch was applied. |
| * @since New in 1.7. */ |
| svn_wc_notify_patch_applied_hunk, |
| |
| /** A hunk from a patch was rejected. |
| * @since New in 1.7. */ |
| svn_wc_notify_patch_rejected_hunk, |
| |
| /** A hunk from a patch was found to already be applied. |
| * @since New in 1.7. */ |
| svn_wc_notify_patch_hunk_already_applied, |
| |
| /** Committing a non-overwriting copy (path is the target of the |
| * copy, not the source). |
| * @since New in 1.7. */ |
| svn_wc_notify_commit_copied, |
| |
| /** Committing an overwriting (replace) copy (path is the target of |
| * the copy, not the source). |
| * @since New in 1.7. */ |
| svn_wc_notify_commit_copied_replaced, |
| |
| /** The server has instructed the client to follow a URL |
| * redirection. |
| * @since New in 1.7. */ |
| svn_wc_notify_url_redirect, |
| |
| /** The operation was attempted on a path which doesn't exist. |
| * @since New in 1.7. */ |
| svn_wc_notify_path_nonexistent, |
| |
| /** Removing a path by excluding it. |
| * @since New in 1.7. */ |
| svn_wc_notify_exclude, |
| |
| /** Operation failed because the node remains in conflict |
| * @since New in 1.7. */ |
| svn_wc_notify_failed_conflict, |
| |
| /** Operation failed because an added node is missing |
| * @since New in 1.7. */ |
| svn_wc_notify_failed_missing, |
| |
| /** Operation failed because a node is out of date |
| * @since New in 1.7. */ |
| svn_wc_notify_failed_out_of_date, |
| |
| /** Operation failed because an added parent is not selected |
| * @since New in 1.7. */ |
| svn_wc_notify_failed_no_parent, |
| |
| /** Operation failed because a node is locked by another user and/or |
| * working copy. @since New in 1.7. */ |
| svn_wc_notify_failed_locked, |
| |
| /** Operation failed because the operation was forbidden by the server. |
| * @since New in 1.7. */ |
| svn_wc_notify_failed_forbidden_by_server, |
| |
| /** The operation skipped the path because it was conflicted. |
| * @since New in 1.7. */ |
| svn_wc_notify_skip_conflicted, |
| |
| /** Just the lock on a file was removed during update. |
| * @since New in 1.8. */ |
| svn_wc_notify_update_broken_lock, |
| |
| /** Operation failed because a node is obstructed. |
| * @since New in 1.8. */ |
| svn_wc_notify_failed_obstruction, |
| |
| /** Conflict resolver is starting. |
| * This can be used by clients to detect when to display conflict summary |
| * information, for example. |
| * @since New in 1.8. */ |
| svn_wc_notify_conflict_resolver_starting, |
| |
| /** Conflict resolver is done. |
| * This can be used by clients to detect when to display conflict summary |
| * information, for example. |
| * @since New in 1.8. */ |
| svn_wc_notify_conflict_resolver_done, |
| |
| /** The current operation left local changes of something that was deleted |
| * The changes are available on (and below) the notified path |
| * @since New in 1.8. */ |
| svn_wc_notify_left_local_modifications, |
| |
| /** A copy from a foreign repository has started |
| * @since New in 1.8. */ |
| svn_wc_notify_foreign_copy_begin, |
| |
| /** A move in the working copy has been broken, i.e. degraded into a |
| * copy + delete. The notified path is the move source (the deleted path). |
| * ### TODO: Provide path to move destination as well? |
| * @since New in 1.8. */ |
| svn_wc_notify_move_broken, |
| |
| /** Running cleanup on an external module. |
| * @since New in 1.9. */ |
| svn_wc_notify_cleanup_external, |
| |
| /** The operation failed because the operation (E.g. commit) is only valid |
| * if the operation includes this path. |
| * @since New in 1.9. */ |
| svn_wc_notify_failed_requires_target, |
| |
| /** Running info on an external module. |
| * @since New in 1.9. */ |
| svn_wc_notify_info_external, |
| |
| /** Finalizing commit. |
| * @since New in 1.9. */ |
| svn_wc_notify_commit_finalizing, |
| |
| /** All text conflicts in a file were marked as resolved. |
| * @since New in 1.10. */ |
| svn_wc_notify_resolved_text, |
| |
| /** A property conflict on a path was marked as resolved. |
| * The name of the property is specified in #svn_wc_notify_t.prop_name. |
| * @since New in 1.10. */ |
| svn_wc_notify_resolved_prop, |
| |
| /** A tree conflict on a path was marked as resolved. |
| * @since New in 1.10. */ |
| svn_wc_notify_resolved_tree, |
| |
| /** Starting to search the repository for details about a tree conflict. |
| * @since New in 1.10. */ |
| svn_wc_notify_begin_search_tree_conflict_details, |
| |
| /** Progressing in search of repository for details about a tree conflict. |
| * The revision being searched is specified in #svn_wc_notify_t.revision. |
| * @since New in 1.10. */ |
| svn_wc_notify_tree_conflict_details_progress, |
| |
| /** Done searching the repository for details about a conflict. |
| * @since New in 1.10. */ |
| svn_wc_notify_end_search_tree_conflict_details, |
| |
| /** Hydrating (fetching text-bases): starting a batch of fetching |
| * within the WC subtree at @c svn_wc_notify_t.path. (Zero or more files |
| * may be fetched, each preceded by @c svn_wc_notify_hydrating_file.) |
| * @since New in 1.15. */ |
| svn_wc_notify_hydrating_start, |
| |
| /** Hydrating (fetching text-bases): about to fetch a file |
| * from @c svn_wc_notify_t.url at @c svn_wc_notify_t.revision. |
| * @since New in 1.15. */ |
| svn_wc_notify_hydrating_file, |
| |
| /** Hydrating (fetching text-bases): finished a batch of fetching |
| * within the WC subtree at @c svn_wc_notify_t.path. |
| * @since New in 1.15. */ |
| svn_wc_notify_hydrating_end, |
| |
| /** A warning, specified in #svn_wc_notify_t.err. |
| * @since New in 1.15. */ |
| svn_wc_notify_warning, |
| |
| } svn_wc_notify_action_t; |
| |
| |
| /** The type of notification that is occurring. */ |
| typedef enum svn_wc_notify_state_t |
| { |
| svn_wc_notify_state_inapplicable = 0, |
| |
| /** Notifier doesn't know or isn't saying. */ |
| svn_wc_notify_state_unknown, |
| |
| /** The state did not change. */ |
| svn_wc_notify_state_unchanged, |
| |
| /** The item wasn't present. */ |
| svn_wc_notify_state_missing, |
| |
| /** An unversioned item obstructed work. */ |
| svn_wc_notify_state_obstructed, |
| |
| /** Pristine state was modified. */ |
| svn_wc_notify_state_changed, |
| |
| /** Modified state had mods merged in. */ |
| svn_wc_notify_state_merged, |
| |
| /** Modified state got conflicting mods. */ |
| svn_wc_notify_state_conflicted, |
| |
| /** The source to copy the file from is missing. */ |
| svn_wc_notify_state_source_missing |
| |
| } svn_wc_notify_state_t; |
| |
| /** |
| * What happened to a lock during an operation. |
| * |
| * @since New in 1.2. |
| */ |
| typedef enum svn_wc_notify_lock_state_t |
| { |
| svn_wc_notify_lock_state_inapplicable = 0, |
| |
| svn_wc_notify_lock_state_unknown, |
| |
| /** The lock wasn't changed. */ |
| svn_wc_notify_lock_state_unchanged, |
| |
| /** The item was locked. */ |
| svn_wc_notify_lock_state_locked, |
| |
| /** The item was unlocked. */ |
| svn_wc_notify_lock_state_unlocked |
| |
| } svn_wc_notify_lock_state_t; |
| |
| /** |
| * Structure used in the #svn_wc_notify_func2_t function. |
| * |
| * @c kind, @c content_state, @c prop_state and @c lock_state are from |
| * after @c action, not before. |
| * |
| * @note If @c action is #svn_wc_notify_update_completed, then @c path has |
| * already been installed, so it is legitimate for an implementation of |
| * #svn_wc_notify_func2_t to examine @c path in the working copy. |
| * |
| * @note The purpose of the @c kind, @c mime_type, @c content_state, and |
| * @c prop_state fields is to provide "for free" information that an |
| * implementation is likely to want, and which it would otherwise be |
| * forced to deduce via expensive operations such as reading entries |
| * and properties. However, if the caller does not have this |
| * information, it will simply pass the corresponding `*_unknown' |
| * values, and it is up to the implementation how to handle that |
| * (i.e., whether to attempt deduction, or just to punt and |
| * give a less informative notification). |
| * |
| * @note Callers of notification functions should use svn_wc_create_notify() |
| * or svn_wc_create_notify_url() to create structures of this type to allow |
| * for extensibility. |
| * |
| * @since New in 1.2. |
| */ |
| typedef struct svn_wc_notify_t { |
| |
| /** Path, either absolute or relative to the current working directory |
| * (i.e., not relative to an anchor). @c path is "." or another valid path |
| * value for compatibility reasons when the real target is a url that |
| * is available in @c url. */ |
| const char *path; |
| |
| /** Action that describes what happened to #svn_wc_notify_t.path. */ |
| svn_wc_notify_action_t action; |
| |
| /** Node kind of @c path. */ |
| svn_node_kind_t kind; |
| |
| /** If non-NULL, indicates the mime-type of @c path. |
| * It is always @c NULL for directories. */ |
| const char *mime_type; |
| |
| /** Points to the lock structure received from the repository when |
| * @c action is #svn_wc_notify_locked. For other actions, it is |
| * @c NULL. */ |
| const svn_lock_t *lock; |
| |
| /** Points to an error describing the reason for the failure when @c |
| * action is one of the following: #svn_wc_notify_failed_lock, |
| * #svn_wc_notify_failed_unlock, #svn_wc_notify_failed_external. |
| * Is @c NULL otherwise. */ |
| svn_error_t *err; |
| |
| /** The type of notification that is occurring about node content. */ |
| svn_wc_notify_state_t content_state; |
| |
| /** The type of notification that is occurring about node properties. */ |
| svn_wc_notify_state_t prop_state; |
| |
| /** Reflects the addition or removal of a lock token in the working copy. */ |
| svn_wc_notify_lock_state_t lock_state; |
| |
| /** When @c action is #svn_wc_notify_update_completed, target revision |
| * of the update, or #SVN_INVALID_REVNUM if not available; when @c |
| * action is #svn_wc_notify_blame_revision, processed revision; Since |
| * Subversion 1.7 when action is #svn_wc_notify_update_update or |
| * #svn_wc_notify_update_add, the target revision. |
| * In all other cases, it is #SVN_INVALID_REVNUM. |
| */ |
| svn_revnum_t revision; |
| |
| /** If @c action pertains to a changelist, this is the changelist name. |
| * In all other cases, it is @c NULL. @since New in 1.5 */ |
| const char *changelist_name; |
| |
| /** When @c action is #svn_wc_notify_merge_begin or |
| * #svn_wc_notify_foreign_merge_begin or |
| * #svn_wc_notify_merge_record_info_begin, and both the |
| * left and right sides of the merge are from the same URL. In all |
| * other cases, it is @c NULL. @since New in 1.5 */ |
| svn_merge_range_t *merge_range; |
| |
| /** Similar to @c path, but if non-NULL the notification is about a url. |
| * @since New in 1.6 */ |
| const char *url; |
| |
| /** If non-NULL, specifies an absolute path prefix that can be subtracted |
| * from the start of the absolute path in @c path or @c url. Its purpose |
| * is to allow notification to remove a common prefix from all the paths |
| * displayed for an operation. @since New in 1.6 */ |
| const char *path_prefix; |
| |
| /** If @c action relates to properties, specifies the name of the property. |
| * @since New in 1.6 */ |
| const char *prop_name; |
| |
| /** If @c action is #svn_wc_notify_blame_revision, contains a list of |
| * revision properties for the specified revision |
| * @since New in 1.6 */ |
| apr_hash_t *rev_props; |
| |
| /** If @c action is #svn_wc_notify_update_update or |
| * #svn_wc_notify_update_add, contains the revision before the update. |
| * In all other cases, it is #SVN_INVALID_REVNUM. |
| * @since New in 1.7 */ |
| svn_revnum_t old_revision; |
| |
| /** These fields are used by svn patch to identify the |
| * hunk the notification is for. They are line-based |
| * offsets and lengths parsed from the unidiff hunk header. |
| * @since New in 1.7. */ |
| /* @{ */ |
| svn_linenum_t hunk_original_start; |
| svn_linenum_t hunk_original_length; |
| svn_linenum_t hunk_modified_start; |
| svn_linenum_t hunk_modified_length; |
| /* @} */ |
| |
| /** The line at which a hunk was matched (and applied). |
| * @since New in 1.7. */ |
| svn_linenum_t hunk_matched_line; |
| |
| /** The fuzz factor the hunk was applied with. |
| * @since New in 1.7 */ |
| svn_linenum_t hunk_fuzz; |
| |
| /* NOTE: Add new fields at the end to preserve binary compatibility. |
| Also, if you add fields here, you have to update svn_wc_create_notify |
| and svn_wc_dup_notify. */ |
| } svn_wc_notify_t; |
| |
| /** |
| * Allocate an #svn_wc_notify_t structure in @a pool, initialize and return |
| * it. |
| * |
| * Set the @c path field of the created struct to @a path, and @c action to |
| * @a action. Set all other fields to their @c _unknown, @c NULL or |
| * invalid value, respectively. Make only a shallow copy of the pointer |
| * @a path. |
| * |
| * @since New in 1.2. |
| */ |
| svn_wc_notify_t * |
| svn_wc_create_notify(const char *path, |
| svn_wc_notify_action_t action, |
| apr_pool_t *pool); |
| |
| /** |
| * Allocate an #svn_wc_notify_t structure in @a pool, initialize and return |
| * it. |
| * |
| * Set the @c url field of the created struct to @a url, @c path to "." and @c |
| * action to @a action. Set all other fields to their @c _unknown, @c NULL or |
| * invalid value, respectively. Make only a shallow copy of the pointer |
| * @a url. |
| * |
| * @since New in 1.6. |
| */ |
| svn_wc_notify_t * |
| svn_wc_create_notify_url(const char *url, |
| svn_wc_notify_action_t action, |
| apr_pool_t *pool); |
| |
| /** |
| * Return a deep copy of @a notify, allocated in @a pool. |
| * |
| * @since New in 1.2. |
| */ |
| svn_wc_notify_t * |
| svn_wc_dup_notify(const svn_wc_notify_t *notify, |
| apr_pool_t *pool); |
| |
| /** |
| * Notify the world that @a notify->action has happened to @a notify->path. |
| * |
| * Recommendation: callers of #svn_wc_notify_func2_t should avoid |
| * invoking it multiple times on the same path within a given |
| * operation, and implementations should not bother checking for such |
| * duplicate calls. For example, in an update, the caller should not |
| * invoke the notify func on receiving a prop change and then again |
| * on receiving a text change. Instead, wait until all changes have |
| * been received, and then invoke the notify func once (from within |
| * an #svn_delta_editor_t's close_file(), for example), passing |
| * the appropriate @a notify->content_state and @a notify->prop_state flags. |
| * |
| * @since New in 1.2. |
| */ |
| typedef void (*svn_wc_notify_func2_t)(void *baton, |
| const svn_wc_notify_t *notify, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to #svn_wc_notify_func2_t, but takes the information as arguments |
| * instead of struct fields. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| typedef void (*svn_wc_notify_func_t)(void *baton, |
| const char *path, |
| svn_wc_notify_action_t action, |
| svn_node_kind_t kind, |
| const char *mime_type, |
| svn_wc_notify_state_t content_state, |
| svn_wc_notify_state_t prop_state, |
| svn_revnum_t revision); |
| |
| /** @} */ |
| |
| |
| /** |
| * Interactive conflict handling |
| * |
| * @defgroup svn_wc_conflict Conflict callback functionality |
| * @{ |
| * |
| * This API gives a Subversion client application the opportunity to |
| * define a callback that allows the user to resolve conflicts |
| * interactively during updates and merges. |
| * |
| * If a conflict is discovered, libsvn_wc invokes the callback with an |
| * #svn_wc_conflict_description_t. This structure describes the |
| * path in conflict, whether it's a text or property conflict, and may |
| * also present up to three files that can be used to resolve the |
| * conflict (perhaps by launching an editor or 3rd-party merging |
| * tool). The structure also provides a possible fourth file (@c |
| * merged_file) which, if not NULL, represents libsvn_wc's attempt to |
| * contextually merge the first three files. (Note that libsvn_wc |
| * will not attempt to merge a file that it believes is binary, and it |
| * will only attempt to merge property values it believes to be a |
| * series of multi-line text.) |
| * |
| * When the callback is finished interacting with the user, it |
| * responds by returning a #svn_wc_conflict_result_t. This |
| * structure indicates whether the user wants to postpone the conflict |
| * for later (allowing libsvn_wc to mark the path "conflicted" as |
| * usual), or whether the user wants libsvn_wc to use one of the four |
| * files as the "final" state for resolving the conflict immediately. |
| * |
| * Note that the callback is at liberty (and encouraged) to merge the |
| * three files itself. If it does so, it signals this to libsvn_wc by |
| * returning a choice of #svn_wc_conflict_choose_merged. To return |
| * the 'final' merged file to libsvn_wc, the callback has the option of |
| * either: |
| * |
| * - editing the original @c merged_file in-place |
| * |
| * or, if libsvn_wc never supplied a merged_file in the |
| * description structure (i.e. passed NULL for that field), |
| * |
| * - return the merged file in the #svn_wc_conflict_result_t. |
| * |
| */ |
| |
| /** The type of action being attempted on an object. |
| * |
| * @since New in 1.5. |
| */ |
| typedef enum svn_wc_conflict_action_t |
| { |
| svn_wc_conflict_action_edit, /**< attempting to change text or props */ |
| svn_wc_conflict_action_add, /**< attempting to add object */ |
| svn_wc_conflict_action_delete, /**< attempting to delete object */ |
| svn_wc_conflict_action_replace /**< attempting to replace object, |
| @since New in 1.7 */ |
| } svn_wc_conflict_action_t; |
| |
| |
| /** The pre-existing condition which is causing a state of conflict. |
| * |
| * @since New in 1.5. |
| */ |
| typedef enum svn_wc_conflict_reason_t |
| { |
| /** Local edits are already present */ |
| svn_wc_conflict_reason_edited, |
| /** Another object is in the way */ |
| svn_wc_conflict_reason_obstructed, |
| /** Object is already schedule-delete */ |
| svn_wc_conflict_reason_deleted, |
| /** Object is unknown or missing */ |
| svn_wc_conflict_reason_missing, |
| /** Object is unversioned */ |
| svn_wc_conflict_reason_unversioned, |
| /** Object is already added or schedule-add. @since New in 1.6. */ |
| svn_wc_conflict_reason_added, |
| /** Object is already replaced. @since New in 1.7. */ |
| svn_wc_conflict_reason_replaced, |
| /** Object is moved away. @since New in 1.8. */ |
| svn_wc_conflict_reason_moved_away, |
| /** Object is moved here. @since New in 1.8. */ |
| svn_wc_conflict_reason_moved_here |
| |
| } svn_wc_conflict_reason_t; |
| |
| |
| /** The type of conflict being described by an |
| * #svn_wc_conflict_description2_t (see below). |
| * |
| * @since New in 1.5. |
| */ |
| typedef enum svn_wc_conflict_kind_t |
| { |
| /** textual conflict (on a file) */ |
| svn_wc_conflict_kind_text, |
| /** property conflict (on a file or dir) */ |
| svn_wc_conflict_kind_property, |
| /** tree conflict (on a dir) @since New in 1.6. */ |
| svn_wc_conflict_kind_tree |
| } svn_wc_conflict_kind_t; |
| |
| |
| /** The user operation that exposed a conflict. |
| * |
| * @since New in 1.6. |
| */ |
| typedef enum svn_wc_operation_t |
| { |
| svn_wc_operation_none = 0, |
| svn_wc_operation_update, |
| svn_wc_operation_switch, |
| svn_wc_operation_merge |
| |
| } svn_wc_operation_t; |
| |
| |
| /** Info about one of the conflicting versions of a node. Each field may |
| * have its respective null/invalid/unknown value if the corresponding |
| * information is not relevant or not available. |
| * |
| * @todo Consider making some or all of the info mandatory, to reduce |
| * complexity. |
| * |
| * @note Fields may be added to the end of this structure in future |
| * versions. Therefore, to preserve binary compatibility, users |
| * should not directly allocate structures of this type. |
| * |
| * @see svn_wc_conflict_version_create() |
| * @see svn_wc_conflict_version_dup() |
| * |
| * @since New in 1.6. |
| */ |
| typedef struct svn_wc_conflict_version_t |
| { |
| /** @name Where to find this node version in a repository */ |
| /**@{*/ |
| |
| /** URL of repository root */ |
| const char *repos_url; |
| |
| /** revision at which to look up path_in_repos */ |
| svn_revnum_t peg_rev; |
| |
| /** path within repos; must not start with '/' */ |
| /* ### should have been called repos_relpath, but we can't change this. */ |
| const char *path_in_repos; |
| /** @} */ |
| |
| /** The node kind. Can be any kind, including 'none' or 'unknown'. */ |
| svn_node_kind_t node_kind; |
| |
| /** UUID of the repository (or NULL if unknown.) |
| * @since New in 1.8. */ |
| const char *repos_uuid; |
| |
| /* @todo Add metadata about a local copy of the node, if and when |
| * we store one. */ |
| |
| /* Remember to update svn_wc_conflict_version_create() and |
| * svn_wc_conflict_version_dup() in case you add fields to this struct. */ |
| } svn_wc_conflict_version_t; |
| |
| /** |
| * Allocate an #svn_wc_conflict_version_t structure in @a pool, |
| * initialize to contain a conflict origin, and return it. |
| * |
| * Set the @c repos_url field of the created struct to @a repos_root_url, |
| * the @c path_in_repos field to @a repos_relpath, the @c peg_rev field to |
| * @a revision and the @c node_kind to @a kind. Make only shallow |
| * copies of the pointer arguments. |
| * |
| * @a repos_root_url, @a repos_relpath and @a revision must be valid, |
| * non-null values. @a repos_uuid should be a valid UUID, but can be |
| * NULL if unknown. @a kind can be any kind, even 'none' or 'unknown'. |
| * |
| * @since New in 1.8. |
| */ |
| svn_wc_conflict_version_t * |
| svn_wc_conflict_version_create2(const char *repos_root_url, |
| const char *repos_uuid, |
| const char *repos_relpath, |
| svn_revnum_t revision, |
| svn_node_kind_t kind, |
| apr_pool_t *result_pool); |
| |
| /** Similar to svn_wc_conflict_version_create2(), but doesn't set all |
| * required values. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for backward compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_wc_conflict_version_t * |
| svn_wc_conflict_version_create(const char *repos_url, |
| const char *path_in_repos, |
| svn_revnum_t peg_rev, |
| svn_node_kind_t node_kind, |
| apr_pool_t *pool); |
| |
| /** Return a duplicate of @a version, allocated in @a pool. |
| * No part of the new version will be shared with @a version. |
| * |
| * @since New in 1.6. |
| */ |
| svn_wc_conflict_version_t * |
| svn_wc_conflict_version_dup(const svn_wc_conflict_version_t *version, |
| apr_pool_t *pool); |
| |
| |
| /** A struct that describes a conflict that has occurred in the |
| * working copy. |
| * |
| * The conflict described by this structure is one of: |
| * - a conflict on the content of the file node @a local_abspath |
| * - a conflict on the property @a property_name of @a local_abspath |
| * - a tree conflict, of which @a local_abspath is the victim |
| * Be aware that the victim of a tree conflict can be a non-existent node. |
| * The three kinds of conflict are distinguished by @a kind. |
| * |
| * @note Fields may be added to the end of this structure in future |
| * versions. Therefore, to preserve binary compatibility, users |
| * should not directly allocate structures of this type but should use |
| * svn_wc_conflict_description_create_text2() or |
| * svn_wc_conflict_description_create_prop2() or |
| * svn_wc_conflict_description_create_tree2() instead. |
| * |
| * @since New in 1.7. |
| */ |
| typedef struct svn_wc_conflict_description2_t |
| { |
| /** The path that is in conflict (for a tree conflict, it is the victim) */ |
| const char *local_abspath; |
| |
| /** The node type of the local node involved in this conflict. |
| * For a tree conflict, this is the node kind of the tree conflict victim. |
| * For the left/right node kinds of the incoming conflicting change see |
| * src_left_version->node_kind and src_right_version->node_kind. */ |
| svn_node_kind_t node_kind; |
| |
| /** What sort of conflict are we describing? */ |
| svn_wc_conflict_kind_t kind; |
| |
| /** The name of the property whose conflict is being described. |
| * (Only if @a kind is 'property'; else undefined.) */ |
| const char *property_name; |
| |
| /** Whether svn thinks ('my' version of) @c path is a 'binary' file. |
| * (Only if @c kind is 'text', else undefined.) */ |
| svn_boolean_t is_binary; |
| |
| /** The svn:mime-type property of ('my' version of) @c path, if available, |
| * else NULL. |
| * (Only if @c kind is 'text', else undefined.) */ |
| const char *mime_type; |
| |
| /** The incoming action being attempted on the conflicted node or property. |
| * When @c kind is 'text', this action must be 'edit', but generally it can |
| * be any kind of possible change. */ |
| svn_wc_conflict_action_t action; |
| |
| /** The local change or state of the target node or property, relative |
| * to its merge-left source, that conflicts with the incoming action. |
| * When @c kind is 'text', this must be 'edited', but generally it can |
| * be any kind of possible change. |
| * Note that 'local' does not always refer to a working copy. A change |
| * can be local to the target branch of a merge operation, for example, |
| * and is not necessarily visible in a working copy of the target branch |
| * at any given revision. */ |
| svn_wc_conflict_reason_t reason; |
| |
| /** If this is text-conflict and involves the merging of two files |
| * descended from a common ancestor, here are the paths of up to |
| * four fulltext files that can be used to interactively resolve the |
| * conflict. |
| * |
| * @a base_abspath, @a their_abspath and @a my_abspath are absolute |
| * paths. |
| * |
| * ### Is @a merged_file relative to some directory, or absolute? |
| * |
| * All four files will be in repository-normal form -- LF |
| * line endings and contracted keywords. (If any of these files are |
| * not available, they default to NULL.) |
| * |
| * On the other hand, if this is a property-conflict, then these |
| * paths represent temporary files that contain the three different |
| * property-values in conflict. The fourth path (@c merged_file) |
| * may or may not be NULL; if set, it represents libsvn_wc's |
| * attempt to merge the property values together. (Remember that |
| * property values are technically binary values, and thus can't |
| * always be merged.) |
| */ |
| const char *base_abspath; /* common ancestor of the two files being merged */ |
| |
| /** their version of the file */ |
| /* ### BH: For properties this field contains the reference to |
| the property rejection (.prej) file */ |
| const char *their_abspath; |
| |
| /** my locally-edited version of the file */ |
| const char *my_abspath; |
| |
| /** merged version; may contain conflict markers |
| * ### For property conflicts, this contains 'their_abspath'. */ |
| const char *merged_file; |
| |
| /** The operation that exposed the conflict. |
| * Used only for tree conflicts. |
| */ |
| svn_wc_operation_t operation; |
| |
| /** Info on the "merge-left source" or "older" version of incoming change. */ |
| const svn_wc_conflict_version_t *src_left_version; |
| |
| /** Info on the "merge-right source" or "their" version of incoming change. */ |
| const svn_wc_conflict_version_t *src_right_version; |
| |
| /** For property conflicts, the absolute path to the .prej file. |
| * @since New in 1.9. */ |
| const char *prop_reject_abspath; |
| |
| /** For property conflicts, the local base value of the property, i.e. the |
| * value of the property as of the BASE revision of the working copy. |
| * For conflicts created during update/switch this contains the |
| * post-update/switch property value. The pre-update/switch value can |
| * be found in prop_value_incoming_old. |
| * Only set if available, so might be @c NULL. |
| * @since New in 1.9. */ |
| const svn_string_t *prop_value_base; |
| |
| /** For property conflicts, the local working value of the property, |
| * i.e. the value of the property in the working copy, possibly with |
| * local modiciations. |
| * Only set if available, so might be @c NULL. |
| * @since New in 1.9. */ |
| const svn_string_t *prop_value_working; |
| |
| /** For property conflicts, the incoming old value of the property, |
| * i.e. the value the property had at @c src_left_version. |
| * Only set if available, so might be @c NULL. |
| * @since New in 1.9 */ |
| const svn_string_t *prop_value_incoming_old; |
| |
| /** For property conflicts, the incoming new value of the property, |
| * i.e. the value the property had at @c src_right_version. |
| * Only set if available, so might be @c NULL. |
| * @since New in 1.9 */ |
| const svn_string_t *prop_value_incoming_new; |
| |
| /* NOTE: Add new fields at the end to preserve binary compatibility. |
| Also, if you add fields here, you have to update |
| svn_wc_conflict_description2_dup and perhaps |
| svn_wc_conflict_description_create_text2, |
| svn_wc_conflict_description_create_prop2, and |
| svn_wc_conflict_description_create_tree2. */ |
| } svn_wc_conflict_description2_t; |
| |
| |
| /** Similar to #svn_wc_conflict_description2_t, but with relative paths and |
| * adm_access batons. Passed to #svn_wc_conflict_resolver_func_t. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| typedef struct svn_wc_conflict_description_t |
| { |
| /** The path that is in conflict (for a tree conflict, it is the victim) */ |
| const char *path; |
| |
| /** The local node type of the path being operated on (for a tree conflict, |
| * this specifies the local node kind, which may be (and typically is) |
| * different than the left and right kind) */ |
| svn_node_kind_t node_kind; |
| |
| /** What sort of conflict are we describing? */ |
| svn_wc_conflict_kind_t kind; |
| |
| /** The name of the property whose conflict is being described. |
| * (Only if @a kind is 'property'; else undefined.) */ |
| const char *property_name; |
| |
| /** Whether svn thinks ('my' version of) @c path is a 'binary' file. |
| * (Only if @c kind is 'text', else undefined.) */ |
| svn_boolean_t is_binary; |
| |
| /** The svn:mime-type property of ('my' version of) @c path, if available, |
| * else NULL. |
| * (Only if @c kind is 'text', else undefined.) */ |
| const char *mime_type; |
| |
| /** If not NULL, an open working copy access baton to either the |
| * path itself (if @c path is a directory), or to the parent |
| * directory (if @c path is a file.) |
| * For a tree conflict, this will always be an access baton |
| * to the parent directory of the path, even if the path is |
| * a directory. */ |
| svn_wc_adm_access_t *access; |
| |
| /** The action being attempted on the conflicted node or property. |
| * (When @c kind is 'text', this action must be 'edit'.) */ |
| svn_wc_conflict_action_t action; |
| |
| /** The state of the target node or property, relative to its merge-left |
| * source, that is the reason for the conflict. |
| * (When @c kind is 'text', this reason must be 'edited'.) */ |
| svn_wc_conflict_reason_t reason; |
| |
| /** If this is text-conflict and involves the merging of two files |
| * descended from a common ancestor, here are the paths of up to |
| * four fulltext files that can be used to interactively resolve the |
| * conflict. All four files will be in repository-normal form -- LF |
| * line endings and contracted keywords. (If any of these files are |
| * not available, they default to NULL.) |
| * |
| * On the other hand, if this is a property-conflict, then these |
| * paths represent temporary files that contain the three different |
| * property-values in conflict. The fourth path (@c merged_file) |
| * may or may not be NULL; if set, it represents libsvn_wc's |
| * attempt to merge the property values together. (Remember that |
| * property values are technically binary values, and thus can't |
| * always be merged.) |
| */ |
| const char *base_file; /* common ancestor of the two files being merged */ |
| |
| /** their version of the file */ |
| const char *their_file; |
| |
| /** my locally-edited version of the file */ |
| const char *my_file; |
| |
| /** merged version; may contain conflict markers */ |
| const char *merged_file; |
| |
| /** The operation that exposed the conflict. |
| * Used only for tree conflicts. |
| * |
| * @since New in 1.6. |
| */ |
| svn_wc_operation_t operation; |
| |
| /** Info on the "merge-left source" or "older" version of incoming change. |
| * @since New in 1.6. */ |
| svn_wc_conflict_version_t *src_left_version; |
| |
| /** Info on the "merge-right source" or "their" version of incoming change. |
| * @since New in 1.6. */ |
| svn_wc_conflict_version_t *src_right_version; |
| |
| } svn_wc_conflict_description_t; |
| |
| /** |
| * Allocate an #svn_wc_conflict_description2_t structure in @a result_pool, |
| * initialize to represent a text conflict, and return it. |
| * |
| * Set the @c local_abspath field of the created struct to @a local_abspath |
| * (which must be an absolute path), the @c kind field to |
| * #svn_wc_conflict_kind_text, the @c node_kind to #svn_node_file, |
| * the @c action to #svn_wc_conflict_action_edit, and the @c reason to |
| * #svn_wc_conflict_reason_edited. |
| * |
| * @note It is the caller's responsibility to set the other required fields |
| * (such as the four file names and @c mime_type and @c is_binary). |
| * |
| * @since New in 1.7. |
| */ |
| svn_wc_conflict_description2_t * |
| svn_wc_conflict_description_create_text2(const char *local_abspath, |
| apr_pool_t *result_pool); |
| |
| |
| /** Similar to svn_wc_conflict_description_create_text2(), but returns |
| * a #svn_wc_conflict_description_t *. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_wc_conflict_description_t * |
| svn_wc_conflict_description_create_text(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| /** |
| * Allocate an #svn_wc_conflict_description2_t structure in @a result_pool, |
| * initialize to represent a property conflict, and return it. |
| * |
| * Set the @c local_abspath field of the created struct to @a local_abspath |
| * (which must be an absolute path), the @c kind field |
| * to #svn_wc_conflict_kind_property, the @c node_kind to @a node_kind, and |
| * the @c property_name to @a property_name. |
| * |
| * @note: It is the caller's responsibility to set the other required fields |
| * (such as the four file names and @c action and @c reason). |
| * |
| * @since New in 1.7. |
| */ |
| svn_wc_conflict_description2_t * |
| svn_wc_conflict_description_create_prop2(const char *local_abspath, |
| svn_node_kind_t node_kind, |
| const char *property_name, |
| apr_pool_t *result_pool); |
| |
| /** Similar to svn_wc_conflict_descriptor_create_prop(), but returns |
| * a #svn_wc_conflict_description_t *. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_wc_conflict_description_t * |
| svn_wc_conflict_description_create_prop(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_node_kind_t node_kind, |
| const char *property_name, |
| apr_pool_t *pool); |
| |
| /** |
| * Allocate an #svn_wc_conflict_description2_t structure in @a pool, |
| * initialize to represent a tree conflict, and return it. |
| * |
| * Set the @c local_abspath field of the created struct to @a local_abspath |
| * (which must be an absolute path), the @c kind field to |
| * #svn_wc_conflict_kind_tree, the @c node_kind to @a node_kind, |
| * the @c operation to @a operation, the @c src_left_version field to |
| * @a src_left_version, and the @c src_right_version field to |
| * @a src_right_version. |
| * |
| * @note: It is the caller's responsibility to set the other required fields |
| * (such as the four file names and @c action and @c reason). |
| * |
| * @since New in 1.7. |
| */ |
| svn_wc_conflict_description2_t * |
| svn_wc_conflict_description_create_tree2( |
| const char *local_abspath, |
| svn_node_kind_t node_kind, |
| svn_wc_operation_t operation, |
| const svn_wc_conflict_version_t *src_left_version, |
| const svn_wc_conflict_version_t *src_right_version, |
| apr_pool_t *result_pool); |
| |
| |
| /** Similar to svn_wc_conflict_description_create_tree(), but returns |
| * a #svn_wc_conflict_description_t *. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_wc_conflict_description_t * |
| svn_wc_conflict_description_create_tree( |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_node_kind_t node_kind, |
| svn_wc_operation_t operation, |
| /* non-const */ svn_wc_conflict_version_t *src_left_version, |
| /* non-const */ svn_wc_conflict_version_t *src_right_version, |
| apr_pool_t *pool); |
| |
| |
| /** Return a duplicate of @a conflict, allocated in @a result_pool. |
| * A deep copy of all members will be made. |
| * |
| * @since New in 1.9. |
| */ |
| svn_wc_conflict_description2_t * |
| svn_wc_conflict_description2_dup( |
| const svn_wc_conflict_description2_t *conflict, |
| apr_pool_t *result_pool); |
| |
| |
| /** Like svn_wc_conflict_description2_dup(), but is improperly named |
| * as a private function when it is intended to be a public API. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.8 API. |
| */ |
| SVN_DEPRECATED |
| svn_wc_conflict_description2_t * |
| svn_wc__conflict_description2_dup( |
| const svn_wc_conflict_description2_t *conflict, |
| apr_pool_t *result_pool); |
| |
| |
| /** The way in which the conflict callback chooses a course of action. |
| * |
| * @since New in 1.5. |
| */ |
| typedef enum svn_wc_conflict_choice_t |
| { |
| /** Undefined; for private use only. |
| This value must never be returned in svn_wc_conflict_result_t, |
| but a separate value, unequal to all other pre-defined values may |
| be useful in conflict resolver implementations to signal that no |
| choice is made yet. |
| * @since New in 1.9 |
| */ |
| svn_wc_conflict_choose_undefined = -1, |
| |
| /** Don't resolve the conflict now. Let libsvn_wc mark the path |
| 'conflicted', so user can run 'svn resolved' later. */ |
| svn_wc_conflict_choose_postpone = 0, |
| |
| /** If there were files to choose from, select one as a way of |
| resolving the conflict here and now. libsvn_wc will then do the |
| work of "installing" the chosen file. |
| */ |
| svn_wc_conflict_choose_base, /**< original version */ |
| svn_wc_conflict_choose_theirs_full, /**< incoming version */ |
| svn_wc_conflict_choose_mine_full, /**< own version */ |
| svn_wc_conflict_choose_theirs_conflict, /**< incoming (for conflicted hunks) */ |
| svn_wc_conflict_choose_mine_conflict, /**< own (for conflicted hunks) */ |
| svn_wc_conflict_choose_merged, /**< merged version */ |
| |
| /** @since New in 1.8. */ |
| svn_wc_conflict_choose_unspecified /**< undecided */ |
| |
| } svn_wc_conflict_choice_t; |
| |
| |
| /** The final result returned by #svn_wc_conflict_resolver_func_t. |
| * |
| * @note Fields may be added to the end of this structure in future |
| * versions. Therefore, to preserve binary compatibility, users |
| * should not directly allocate structures of this type. Instead, |
| * construct this structure using svn_wc_create_conflict_result() |
| * below. |
| * |
| * @since New in 1.5. |
| */ |
| typedef struct svn_wc_conflict_result_t |
| { |
| /** A choice to either delay the conflict resolution or select a |
| particular file to resolve the conflict. */ |
| svn_wc_conflict_choice_t choice; |
| |
| /** If not NULL, this is a path to a file which contains the client's |
| (or more likely, the user's) merging of the three values in |
| conflict. libsvn_wc accepts this file if (and only if) @c choice |
| is set to #svn_wc_conflict_choose_merged.*/ |
| const char *merged_file; |
| |
| /** If true, save a backup copy of merged_file (or the original |
| merged_file from the conflict description, if merged_file is |
| NULL) in the user's working copy. */ |
| svn_boolean_t save_merged; |
| |
| /** If not NULL, this is the new merged property, used when choosing |
| * #svn_wc_conflict_choose_merged. This value is preferred over using |
| * merged_file. |
| * |
| * @since New in 1.9. |
| */ |
| const svn_string_t *merged_value; |
| |
| } svn_wc_conflict_result_t; |
| |
| |
| /** |
| * Allocate an #svn_wc_conflict_result_t structure in @a pool, |
| * initialize and return it. |
| * |
| * Set the @c choice field of the structure to @a choice, @c merged_file |
| * to @a merged_file, and @c save_merged to false. Make only a shallow |
| * copy of the pointer argument @a merged_file. @a merged_file may be |
| * NULL if setting merged_file is not needed. |
| * |
| * @since New in 1.5. |
| */ |
| svn_wc_conflict_result_t * |
| svn_wc_create_conflict_result(svn_wc_conflict_choice_t choice, |
| const char *merged_file, |
| apr_pool_t *pool); |
| |
| |
| /** A callback used in merge, update and switch for resolving conflicts |
| * during the application of a tree delta to a working copy. |
| * |
| * @a description describes the exact nature of the conflict, and |
| * provides information to help resolve it. @a baton is a closure |
| * object; it should be provided by the implementation, and passed by |
| * the caller. When finished, the callback signals its resolution by |
| * returning a structure in @a *result, which should be allocated in |
| * @a result_pool. (See #svn_wc_conflict_result_t.) @a scratch_pool |
| * should be used for any temporary allocations. |
| * |
| * The values #svn_wc_conflict_choose_mine_conflict and |
| * #svn_wc_conflict_choose_theirs_conflict are not legal for conflicts |
| * in binary files or binary properties. |
| * |
| * Implementations of this callback are free to present the conflict |
| * using any user interface. This may include simple contextual |
| * conflicts in a file's text or properties, or more complex |
| * 'tree'-based conflicts related to obstructed additions, deletions, |
| * and edits. The callback implementation is free to decide which |
| * sorts of conflicts to handle; it's also free to decide which types |
| * of conflicts are automatically resolvable and which require user |
| * interaction. |
| * |
| * @since New in 1.7. |
| */ |
| typedef svn_error_t *(*svn_wc_conflict_resolver_func2_t)( |
| svn_wc_conflict_result_t **result, |
| const svn_wc_conflict_description2_t *description, |
| void *baton, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Similar to #svn_wc_conflict_resolver_func2_t, but using |
| * #svn_wc_conflict_description_t instead of |
| * #svn_wc_conflict_description2_t |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| typedef svn_error_t *(*svn_wc_conflict_resolver_func_t)( |
| svn_wc_conflict_result_t **result, |
| const svn_wc_conflict_description_t *description, |
| void *baton, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| |
| /** |
| * A callback vtable invoked by our diff-editors, as they receive diffs |
| * from the server. 'svn diff' and 'svn merge' implement their own versions |
| * of this vtable. |
| * |
| * Common parameters: |
| * |
| * If @a state is non-NULL, set @a *state to the state of the item |
| * after the operation has been performed. (In practice, this is only |
| * useful with merge, not diff; diff callbacks will probably set |
| * @a *state to #svn_wc_notify_state_unknown, since they do not change |
| * the state and therefore do not bother to know the state after the |
| * operation.) By default, @a state refers to the item's content |
| * state. Functions concerned with property state have separate |
| * @a contentstate and @a propstate arguments. |
| * |
| * If @a tree_conflicted is non-NULL, set @a *tree_conflicted to true if |
| * this operation caused a tree conflict, else to false. (Like with @a |
| * state, this is only useful with merge, not diff; diff callbacks |
| * should set this to false.) |
| * |
| * @since New in 1.7. |
| */ |
| typedef struct svn_wc_diff_callbacks4_t |
| { |
| /** |
| * This function is called before @a file_changed to allow callbacks to |
| * skip the most expensive processing of retrieving the file data. |
| * |
| */ |
| svn_error_t *(*file_opened)(svn_boolean_t *tree_conflicted, |
| svn_boolean_t *skip, |
| const char *path, |
| svn_revnum_t rev, |
| void *diff_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * A file @a path has changed. If @a tmpfile2 is non-NULL, the |
| * contents have changed and those changes can be seen by comparing |
| * @a tmpfile1 and @a tmpfile2, which represent @a rev1 and @a rev2 of |
| * the file, respectively. |
| * |
| * If known, the @c svn:mime-type value of each file is passed into |
| * @a mimetype1 and @a mimetype2; either or both of the values can |
| * be NULL. The implementor can use this information to decide if |
| * (or how) to generate differences. |
| * |
| * @a propchanges is an array of (#svn_prop_t) structures. If it contains |
| * any elements, the original list of properties is provided in |
| * @a originalprops, which is a hash of #svn_string_t values, keyed on the |
| * property name. |
| * |
| */ |
| svn_error_t *(*file_changed)(svn_wc_notify_state_t *contentstate, |
| svn_wc_notify_state_t *propstate, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| const char *tmpfile1, |
| const char *tmpfile2, |
| svn_revnum_t rev1, |
| svn_revnum_t rev2, |
| const char *mimetype1, |
| const char *mimetype2, |
| const apr_array_header_t *propchanges, |
| apr_hash_t *originalprops, |
| void *diff_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * A file @a path was added. The contents can be seen by comparing |
| * @a tmpfile1 and @a tmpfile2, which represent @a rev1 and @a rev2 |
| * of the file, respectively. (If either file is empty, the rev |
| * will be 0.) |
| * |
| * If known, the @c svn:mime-type value of each file is passed into |
| * @a mimetype1 and @a mimetype2; either or both of the values can |
| * be NULL. The implementor can use this information to decide if |
| * (or how) to generate differences. |
| * |
| * @a propchanges is an array of (#svn_prop_t) structures. If it contains |
| * any elements, the original list of properties is provided in |
| * @a originalprops, which is a hash of #svn_string_t values, keyed on the |
| * property name. |
| * If @a copyfrom_path is non-@c NULL, this add has history (i.e., is a |
| * copy), and the origin of the copy may be recorded as |
| * @a copyfrom_path under @a copyfrom_revision. |
| */ |
| svn_error_t *(*file_added)(svn_wc_notify_state_t *contentstate, |
| svn_wc_notify_state_t *propstate, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| const char *tmpfile1, |
| const char *tmpfile2, |
| svn_revnum_t rev1, |
| svn_revnum_t rev2, |
| const char *mimetype1, |
| const char *mimetype2, |
| const char *copyfrom_path, |
| svn_revnum_t copyfrom_revision, |
| const apr_array_header_t *propchanges, |
| apr_hash_t *originalprops, |
| void *diff_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * A file @a path was deleted. The [loss of] contents can be seen by |
| * comparing @a tmpfile1 and @a tmpfile2. @a originalprops provides |
| * the properties of the file. |
| * ### Some existing callers include WC "entry props" in @a originalprops. |
| * |
| * If known, the @c svn:mime-type value of each file is passed into |
| * @a mimetype1 and @a mimetype2; either or both of the values can |
| * be NULL. The implementor can use this information to decide if |
| * (or how) to generate differences. |
| */ |
| svn_error_t *(*file_deleted)(svn_wc_notify_state_t *state, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| const char *tmpfile1, |
| const char *tmpfile2, |
| const char *mimetype1, |
| const char *mimetype2, |
| apr_hash_t *originalprops, |
| void *diff_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * A directory @a path was deleted. |
| */ |
| svn_error_t *(*dir_deleted)(svn_wc_notify_state_t *state, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| void *diff_baton, |
| apr_pool_t *scratch_pool); |
| /** |
| * A directory @a path has been opened. @a rev is the revision that the |
| * directory came from. |
| * |
| * This function is called for any existing directory @a path before any |
| * of the callbacks are called for a child of @a path. |
| * |
| * If the callback returns @c TRUE in @a *skip_children, children |
| * of this directory will be skipped. |
| */ |
| svn_error_t *(*dir_opened)(svn_boolean_t *tree_conflicted, |
| svn_boolean_t *skip, |
| svn_boolean_t *skip_children, |
| const char *path, |
| svn_revnum_t rev, |
| void *diff_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * A directory @a path was added. @a rev is the revision that the |
| * directory came from. |
| * |
| * This function is called for any new directory @a path before any |
| * of the callbacks are called for a child of @a path. |
| * |
| * If @a copyfrom_path is non-@c NULL, this add has history (i.e., is a |
| * copy), and the origin of the copy may be recorded as |
| * @a copyfrom_path under @a copyfrom_revision. |
| */ |
| svn_error_t *(*dir_added)(svn_wc_notify_state_t *state, |
| svn_boolean_t *tree_conflicted, |
| svn_boolean_t *skip, |
| svn_boolean_t *skip_children, |
| const char *path, |
| svn_revnum_t rev, |
| const char *copyfrom_path, |
| svn_revnum_t copyfrom_revision, |
| void *diff_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * A list of property changes (@a propchanges) was applied to the |
| * directory @a path. |
| * |
| * The array is a list of (#svn_prop_t) structures. |
| * |
| * @a dir_was_added is set to #TRUE if the directory was added, and |
| * to #FALSE if the directory pre-existed. |
| */ |
| svn_error_t *(*dir_props_changed)(svn_wc_notify_state_t *propstate, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| svn_boolean_t dir_was_added, |
| const apr_array_header_t *propchanges, |
| apr_hash_t *original_props, |
| void *diff_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * A directory @a path which has been opened with @a dir_opened or @a |
| * dir_added has been closed. |
| * |
| * @a dir_was_added is set to #TRUE if the directory was added, and |
| * to #FALSE if the directory pre-existed. |
| */ |
| svn_error_t *(*dir_closed)(svn_wc_notify_state_t *contentstate, |
| svn_wc_notify_state_t *propstate, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| svn_boolean_t dir_was_added, |
| void *diff_baton, |
| apr_pool_t *scratch_pool); |
| |
| } svn_wc_diff_callbacks4_t; |
| |
| |
| /** |
| * Similar to #svn_wc_diff_callbacks4_t, but without @a copyfrom_path and |
| * @a copyfrom_revision arguments to @c file_added and @c dir_added functions. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| typedef struct svn_wc_diff_callbacks3_t |
| { |
| /** The same as #svn_wc_diff_callbacks4_t.file_changed. */ |
| svn_error_t *(*file_changed)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *contentstate, |
| svn_wc_notify_state_t *propstate, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| const char *tmpfile1, |
| const char *tmpfile2, |
| svn_revnum_t rev1, |
| svn_revnum_t rev2, |
| const char *mimetype1, |
| const char *mimetype2, |
| const apr_array_header_t *propchanges, |
| apr_hash_t *originalprops, |
| void *diff_baton); |
| |
| /** Similar to #svn_wc_diff_callbacks4_t.file_added but without |
| * @a copyfrom_path and @a copyfrom_revision arguments. */ |
| svn_error_t *(*file_added)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *contentstate, |
| svn_wc_notify_state_t *propstate, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| const char *tmpfile1, |
| const char *tmpfile2, |
| svn_revnum_t rev1, |
| svn_revnum_t rev2, |
| const char *mimetype1, |
| const char *mimetype2, |
| const apr_array_header_t *propchanges, |
| apr_hash_t *originalprops, |
| void *diff_baton); |
| |
| /** The same as #svn_wc_diff_callbacks4_t.file_deleted. */ |
| svn_error_t *(*file_deleted)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| const char *tmpfile1, |
| const char *tmpfile2, |
| const char *mimetype1, |
| const char *mimetype2, |
| apr_hash_t *originalprops, |
| void *diff_baton); |
| |
| /** Similar to #svn_wc_diff_callbacks4_t.dir_added but without |
| * @a copyfrom_path and @a copyfrom_revision arguments. */ |
| svn_error_t *(*dir_added)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| svn_revnum_t rev, |
| void *diff_baton); |
| |
| /** The same as #svn_wc_diff_callbacks4_t.dir_deleted. */ |
| svn_error_t *(*dir_deleted)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| void *diff_baton); |
| |
| /** The same as #svn_wc_diff_callbacks4_t.dir_props_changed. */ |
| svn_error_t *(*dir_props_changed)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *propstate, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| const apr_array_header_t *propchanges, |
| apr_hash_t *original_props, |
| void *diff_baton); |
| |
| /** The same as #svn_wc_diff_callbacks4_t.dir_opened. */ |
| svn_error_t *(*dir_opened)(svn_wc_adm_access_t *adm_access, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| svn_revnum_t rev, |
| void *diff_baton); |
| |
| /** The same as #svn_wc_diff_callbacks4_t.dir_closed. */ |
| svn_error_t *(*dir_closed)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *contentstate, |
| svn_wc_notify_state_t *propstate, |
| svn_boolean_t *tree_conflicted, |
| const char *path, |
| void *diff_baton); |
| |
| } svn_wc_diff_callbacks3_t; |
| |
| /** |
| * Similar to #svn_wc_diff_callbacks3_t, but without the @c dir_opened |
| * and @c dir_closed functions, and without the @a tree_conflicted argument |
| * to the functions. |
| * |
| * @deprecated Provided for backward compatibility with the 1.2 API. |
| */ |
| typedef struct svn_wc_diff_callbacks2_t |
| { |
| /** The same as @c file_changed in #svn_wc_diff_callbacks3_t. */ |
| svn_error_t *(*file_changed)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *contentstate, |
| svn_wc_notify_state_t *propstate, |
| const char *path, |
| const char *tmpfile1, |
| const char *tmpfile2, |
| svn_revnum_t rev1, |
| svn_revnum_t rev2, |
| const char *mimetype1, |
| const char *mimetype2, |
| const apr_array_header_t *propchanges, |
| apr_hash_t *originalprops, |
| void *diff_baton); |
| |
| /** The same as @c file_added in #svn_wc_diff_callbacks3_t. */ |
| svn_error_t *(*file_added)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *contentstate, |
| svn_wc_notify_state_t *propstate, |
| const char *path, |
| const char *tmpfile1, |
| const char *tmpfile2, |
| svn_revnum_t rev1, |
| svn_revnum_t rev2, |
| const char *mimetype1, |
| const char *mimetype2, |
| const apr_array_header_t *propchanges, |
| apr_hash_t *originalprops, |
| void *diff_baton); |
| |
| /** The same as @c file_deleted in #svn_wc_diff_callbacks3_t. */ |
| svn_error_t *(*file_deleted)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| const char *path, |
| const char *tmpfile1, |
| const char *tmpfile2, |
| const char *mimetype1, |
| const char *mimetype2, |
| apr_hash_t *originalprops, |
| void *diff_baton); |
| |
| /** The same as @c dir_added in #svn_wc_diff_callbacks3_t. */ |
| svn_error_t *(*dir_added)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| const char *path, |
| svn_revnum_t rev, |
| void *diff_baton); |
| |
| /** The same as @c dir_deleted in #svn_wc_diff_callbacks3_t. */ |
| svn_error_t *(*dir_deleted)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| const char *path, |
| void *diff_baton); |
| |
| /** The same as @c dir_props_changed in #svn_wc_diff_callbacks3_t. */ |
| svn_error_t *(*dir_props_changed)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| const char *path, |
| const apr_array_header_t *propchanges, |
| apr_hash_t *original_props, |
| void *diff_baton); |
| |
| } svn_wc_diff_callbacks2_t; |
| |
| /** |
| * Similar to #svn_wc_diff_callbacks2_t, but with file additions/content |
| * changes and property changes split into different functions. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| typedef struct svn_wc_diff_callbacks_t |
| { |
| /** Similar to @c file_changed in #svn_wc_diff_callbacks2_t, but without |
| * property change information. @a tmpfile2 is never NULL. @a state applies |
| * to the file contents. */ |
| svn_error_t *(*file_changed)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| const char *path, |
| const char *tmpfile1, |
| const char *tmpfile2, |
| svn_revnum_t rev1, |
| svn_revnum_t rev2, |
| const char *mimetype1, |
| const char *mimetype2, |
| void *diff_baton); |
| |
| /** Similar to @c file_added in #svn_wc_diff_callbacks2_t, but without |
| * property change information. @a *state applies to the file contents. */ |
| svn_error_t *(*file_added)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| const char *path, |
| const char *tmpfile1, |
| const char *tmpfile2, |
| svn_revnum_t rev1, |
| svn_revnum_t rev2, |
| const char *mimetype1, |
| const char *mimetype2, |
| void *diff_baton); |
| |
| /** Similar to @c file_deleted in #svn_wc_diff_callbacks2_t, but without |
| * the properties. */ |
| svn_error_t *(*file_deleted)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| const char *path, |
| const char *tmpfile1, |
| const char *tmpfile2, |
| const char *mimetype1, |
| const char *mimetype2, |
| void *diff_baton); |
| |
| /** The same as @c dir_added in #svn_wc_diff_callbacks2_t. */ |
| svn_error_t *(*dir_added)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| const char *path, |
| svn_revnum_t rev, |
| void *diff_baton); |
| |
| /** The same as @c dir_deleted in #svn_wc_diff_callbacks2_t. */ |
| svn_error_t *(*dir_deleted)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| const char *path, |
| void *diff_baton); |
| |
| /** Similar to @c dir_props_changed in #svn_wc_diff_callbacks2_t, but this |
| * function is called for files as well as directories. */ |
| svn_error_t *(*props_changed)(svn_wc_adm_access_t *adm_access, |
| svn_wc_notify_state_t *state, |
| const char *path, |
| const apr_array_header_t *propchanges, |
| apr_hash_t *original_props, |
| void *diff_baton); |
| |
| } svn_wc_diff_callbacks_t; |
| |
| |
| /* Asking questions about a working copy. */ |
| |
| /** Set @a *wc_format to @a local_abspath's working copy format version |
| * number if @a local_abspath is a valid working copy directory, else set it |
| * to 0. |
| * |
| * Return error @c APR_ENOENT if @a local_abspath does not exist at all. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_check_wc2(int *wc_format, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_check_wc2(), but with a relative path and no supplied |
| * working copy context. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_check_wc(const char *path, |
| int *wc_format, |
| apr_pool_t *pool); |
| |
| |
| /** Set @a *has_binary_prop to @c TRUE iff @a path has been marked |
| * with a property indicating that it is non-text (in other words, binary). |
| * @a adm_access is an access baton set that contains @a path. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. As a |
| * replacement for this functionality, @see svn_mime_type_is_binary and |
| * #SVN_PROP_MIME_TYPE. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_has_binary_prop(svn_boolean_t *has_binary_prop, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| |
| /* Detecting modification. */ |
| |
| /** Set @a *modified_p to non-zero if @a local_abspath's text is modified |
| * with regard to the base revision, else set @a *modified_p to zero. |
| * @a local_abspath is the absolute path to the file. |
| * |
| * This function uses some heuristics to avoid byte-by-byte comparisons |
| * against the base text (eg. file size and its modification time). |
| * |
| * If @a local_abspath does not exist, consider it unmodified. If it exists |
| * but is not under revision control (not even scheduled for |
| * addition), return the error #SVN_ERR_ENTRY_NOT_FOUND. |
| * |
| * @a unused is ignored. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_text_modified_p2(svn_boolean_t *modified_p, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_boolean_t unused, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_text_modified_p2(), but with a relative path and |
| * adm_access baton? |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_text_modified_p(svn_boolean_t *modified_p, |
| const char *filename, |
| svn_boolean_t force_comparison, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| /** Set @a *modified_p to non-zero if @a path's properties are modified |
| * with regard to the base revision, else set @a modified_p to zero. |
| * @a adm_access must be an access baton for @a path. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_props_modified_p2(svn_boolean_t *modified_p, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_props_modified_p2(), but with a relative path and |
| * adm_access baton. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_props_modified_p(svn_boolean_t *modified_p, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * @defgroup svn_wc_entries Entries and status (deprecated) |
| * @{ |
| */ |
| |
| /** The schedule states an entry can be in. |
| * @deprecated Provided for backward compatibility with the 1.6 API. */ |
| typedef enum svn_wc_schedule_t |
| { |
| /** Nothing special here */ |
| svn_wc_schedule_normal, |
| |
| /** Slated for addition */ |
| svn_wc_schedule_add, |
| |
| /** Slated for deletion */ |
| svn_wc_schedule_delete, |
| |
| /** Slated for replacement (delete + add) */ |
| svn_wc_schedule_replace |
| |
| } svn_wc_schedule_t; |
| |
| |
| /** |
| * Values for the working_size field in svn_wc_entry_t |
| * when it isn't set to the actual size value of the unchanged |
| * working file. |
| * |
| * The value of the working size is unknown (hasn't been |
| * calculated and stored in the past for whatever reason). |
| * |
| * @since New in 1.5 |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| #define SVN_WC_ENTRY_WORKING_SIZE_UNKNOWN (-1) |
| |
| /** A working copy entry -- that is, revision control information about |
| * one versioned entity. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| /* SVN_DEPRECATED */ |
| typedef struct svn_wc_entry_t |
| { |
| /* IMPORTANT: If you extend this structure, add new fields to the end. */ |
| |
| /* General Attributes */ |
| |
| /** entry's name */ |
| const char *name; |
| |
| /** base revision */ |
| svn_revnum_t revision; |
| |
| /** url in repository */ |
| const char *url; |
| |
| /** canonical repository URL or NULL if not known */ |
| const char *repos; |
| |
| /** repository uuid */ |
| const char *uuid; |
| |
| /** node kind (file, dir, ...) */ |
| svn_node_kind_t kind; |
| |
| /* State information */ |
| |
| /** scheduling (add, delete, replace ...) */ |
| svn_wc_schedule_t schedule; |
| |
| /** in a copied state (possibly because the entry is a child of a |
| * path that is #svn_wc_schedule_add or #svn_wc_schedule_replace, |
| * when the entry itself is #svn_wc_schedule_normal). |
| * COPIED is true for nodes under a directory that was copied, but |
| * COPYFROM_URL is null there. They are both set for the root |
| * destination of the copy. |
| */ |
| svn_boolean_t copied; |
| |
| /** The directory containing this entry had a versioned child of this |
| * name, but this entry represents a different revision or a switched |
| * path at which no item exists in the repository. This typically |
| * arises from committing or updating to a deletion of this entry |
| * without committing or updating the parent directory. |
| * |
| * The schedule can be 'normal' or 'add'. */ |
| svn_boolean_t deleted; |
| |
| /** absent -- we know an entry of this name exists, but that's all |
| (usually this happens because of authz restrictions) */ |
| svn_boolean_t absent; |
| |
| /** for THIS_DIR entry, implies whole entries file is incomplete */ |
| svn_boolean_t incomplete; |
| |
| /** copyfrom location */ |
| const char *copyfrom_url; |
| |
| /** copyfrom revision */ |
| svn_revnum_t copyfrom_rev; |
| |
| /** old version of conflicted file. A file basename, relative to the |
| * user's directory that the THIS_DIR entry refers to. */ |
| const char *conflict_old; |
| |
| /** new version of conflicted file. A file basename, relative to the |
| * user's directory that the THIS_DIR entry refers to. */ |
| const char *conflict_new; |
| |
| /** working version of conflicted file. A file basename, relative to the |
| * user's directory that the THIS_DIR entry refers to. */ |
| const char *conflict_wrk; |
| |
| /** property reject file. A file basename, relative to the user's |
| * directory that the THIS_DIR entry refers to. */ |
| const char *prejfile; |
| |
| /** last up-to-date time for text contents (0 means no information available) |
| */ |
| apr_time_t text_time; |
| |
| /** last up-to-date time for properties (0 means no information available) |
| * |
| * @deprecated This value will always be 0 in version 1.4 and later. |
| */ |
| apr_time_t prop_time; |
| |
| /** Hex MD5 checksum for the untranslated text base file, |
| * can be @c NULL for backwards compatibility. |
| */ |
| const char *checksum; |
| |
| /* "Entry props" */ |
| |
| /** last revision this was changed */ |
| svn_revnum_t cmt_rev; |
| |
| /** last date this was changed */ |
| apr_time_t cmt_date; |
| |
| /** last commit author of this item */ |
| const char *cmt_author; |
| |
| /** lock token or NULL if path not locked in this WC |
| * @since New in 1.2. |
| */ |
| const char *lock_token; |
| |
| /** lock owner, or NULL if not locked in this WC |
| * @since New in 1.2. |
| */ |
| const char *lock_owner; |
| |
| /** lock comment or NULL if not locked in this WC or no comment |
| * @since New in 1.2. |
| */ |
| const char *lock_comment; |
| |
| /** Lock creation date or 0 if not locked in this WC |
| * @since New in 1.2. |
| */ |
| apr_time_t lock_creation_date; |
| |
| /** Whether this entry has any working properties. |
| * False if this information is not stored in the entry. |
| * |
| * @since New in 1.4. */ |
| svn_boolean_t has_props; |
| |
| /** Whether this entry has property modifications. |
| * |
| * @note For working copies in older formats, this flag is not valid. |
| * |
| * @see svn_wc_props_modified_p(). |
| * |
| * @since New in 1.4. */ |
| svn_boolean_t has_prop_mods; |
| |
| /** A space-separated list of all properties whose presence/absence is cached |
| * in this entry. |
| * |
| * @see @c present_props. |
| * |
| * @since New in 1.4. |
| * @deprecated This value will always be "" in version 1.7 and later. */ |
| const char *cachable_props; |
| |
| /** Cached property existence for this entry. |
| * This is a space-separated list of property names. If a name exists in |
| * @c cachable_props but not in this list, this entry does not have that |
| * property. If a name exists in both lists, the property is present on this |
| * entry. |
| * |
| * @since New in 1.4. |
| * @deprecated This value will always be "" in version 1.7 and later. */ |
| const char *present_props; |
| |
| /** which changelist this item is part of, or NULL if not part of any. |
| * @since New in 1.5. |
| */ |
| const char *changelist; |
| |
| /** Size of the file after being translated into local |
| * representation, or #SVN_WC_ENTRY_WORKING_SIZE_UNKNOWN if |
| * unknown. |
| * |
| * @since New in 1.5. |
| */ |
| apr_off_t working_size; |
| |
| /** Whether a local copy of this entry should be kept in the working copy |
| * after a deletion has been committed, Only valid for the this-dir entry |
| * when it is scheduled for deletion. |
| * |
| * @since New in 1.5. */ |
| svn_boolean_t keep_local; |
| |
| /** The depth of this entry. |
| * |
| * ### It's a bit annoying that we only use this on this_dir |
| * ### entries, yet it will exist (with value svn_depth_infinity) on |
| * ### all entries. Maybe some future extensibility would make this |
| * ### field meaningful on entries besides this_dir. |
| * |
| * @since New in 1.5. */ |
| svn_depth_t depth; |
| |
| /** Serialized data for all of the tree conflicts detected in this_dir. |
| * |
| * @since New in 1.6. */ |
| const char *tree_conflict_data; |
| |
| /** The entry is a intra-repository file external and this is the |
| * repository root relative path to the file specified in the |
| * externals definition, otherwise NULL if the entry is not a file |
| * external. |
| * |
| * @since New in 1.6. */ |
| const char *file_external_path; |
| |
| /** The entry is a intra-repository file external and this is the |
| * peg revision number specified in the externals definition. This |
| * field is only valid when the file_external_path field is |
| * non-NULL. The only permissible values are |
| * svn_opt_revision_unspecified if the entry is not an external, |
| * svn_opt_revision_head if the external revision is unspecified or |
| * specified with -r HEAD or svn_opt_revision_number for a specific |
| * revision number. |
| * |
| * @since New in 1.6. */ |
| svn_opt_revision_t file_external_peg_rev; |
| |
| /** The entry is an intra-repository file external and this is the |
| * operative revision number specified in the externals definition. |
| * This field is only valid when the file_external_path field is |
| * non-NULL. The only permissible values are |
| * svn_opt_revision_unspecified if the entry is not an external, |
| * svn_opt_revision_head if the external revision is unspecified or |
| * specified with -r HEAD or svn_opt_revision_number for a specific |
| * revision number. |
| * |
| * @since New in 1.6. */ |
| svn_opt_revision_t file_external_rev; |
| |
| /* IMPORTANT: If you extend this structure, check the following functions in |
| * subversion/libsvn_wc/entries.c, to see if you need to extend them as well. |
| * |
| * svn_wc__atts_to_entry() |
| * svn_wc_entry_dup() |
| * alloc_entry() |
| * read_entry() |
| * write_entry() |
| * fold_entry() |
| */ |
| } svn_wc_entry_t; |
| |
| |
| /** How an entries file's owner dir is named in the entries file. |
| * @deprecated Provided for backward compatibility with the 1.6 API. */ |
| #define SVN_WC_ENTRY_THIS_DIR "" |
| |
| |
| /** Set @a *entry to an entry for @a path, allocated in the access baton pool. |
| * If @a show_hidden is TRUE, return the entry even if it's in 'excluded', |
| * 'deleted' or 'absent' state. Excluded entries are those with their depth |
| * set to #svn_depth_exclude. If @a path is not under revision control, or |
| * if entry is hidden, not scheduled for re-addition, and @a show_hidden is @c |
| * FALSE, then set @a *entry to @c NULL. |
| * |
| * @a *entry should not be modified, since doing so modifies the entries |
| * cache in @a adm_access without changing the entries file on disk. |
| * |
| * If @a path is not a directory then @a adm_access must be an access baton |
| * for the parent directory of @a path. To avoid needing to know whether |
| * @a path is a directory or not, if @a path is a directory @a adm_access |
| * can still be an access baton for the parent of @a path so long as the |
| * access baton for @a path itself is in the same access baton set. |
| * |
| * @a path can be relative or absolute but must share the same base used |
| * to open @a adm_access. |
| * |
| * Note that it is possible for @a path to be absent from disk but still |
| * under revision control; and conversely, it is possible for @a path to |
| * be present, but not under revision control. |
| * |
| * Use @a pool only for local processing. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_entry(const svn_wc_entry_t **entry, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t show_hidden, |
| apr_pool_t *pool); |
| |
| |
| /** Parse the `entries' file for @a adm_access and return a hash @a entries, |
| * whose keys are (<tt>const char *</tt>) entry names and values are |
| * (<tt>svn_wc_entry_t *</tt>). The hash @a entries, and its keys and |
| * values, are allocated from the pool used to open the @a adm_access |
| * baton (that's how the entries caching works). @a pool is used for |
| * transient allocations. |
| * |
| * Entries that are in a 'excluded', 'deleted' or 'absent' state (and not |
| * scheduled for re-addition) are not returned in the hash, unless |
| * @a show_hidden is TRUE. Excluded entries are those with their depth set to |
| * #svn_depth_exclude. |
| * |
| * @par Important: |
| * The @a entries hash is the entries cache in @a adm_access |
| * and so usually the hash itself, the keys and the values should be treated |
| * as read-only. If any of these are modified then it is the caller's |
| * responsibility to ensure that the entries file on disk is updated. Treat |
| * the hash values as type (<tt>const svn_wc_entry_t *</tt>) if you wish to |
| * avoid accidental modification. Modifying the schedule member is a |
| * particularly bad idea, as the entries writing process relies on having |
| * access to the original schedule. Use a duplicate entry to modify the |
| * schedule. |
| * |
| * @par Important: |
| * Only the entry structures representing files and |
| * #SVN_WC_ENTRY_THIS_DIR contain complete information. The entry |
| * structures representing subdirs have only the `kind' and `state' |
| * fields filled in. If you want info on a subdir, you must use this |
| * routine to open its @a path and read the #SVN_WC_ENTRY_THIS_DIR |
| * structure, or call svn_wc_entry() on its @a path. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_entries_read(apr_hash_t **entries, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t show_hidden, |
| apr_pool_t *pool); |
| |
| |
| /** Return a duplicate of @a entry, allocated in @a pool. No part of the new |
| * entry will be shared with @a entry. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_wc_entry_t * |
| svn_wc_entry_dup(const svn_wc_entry_t *entry, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** |
| * This struct contains information about a working copy node. |
| * |
| * @note Fields may be added to the end of this structure in future |
| * versions. Therefore, users shouldn't allocate structures of this |
| * type, to preserve binary compatibility. |
| * |
| * @since New in 1.7. |
| */ |
| typedef struct svn_wc_info_t |
| { |
| /** The schedule of this item |
| * ### Do we still need schedule? */ |
| svn_wc_schedule_t schedule; |
| |
| /** If copied, the URL from which the copy was made, else @c NULL. */ |
| const char *copyfrom_url; |
| |
| /** If copied, the revision from which the copy was made, |
| * else #SVN_INVALID_REVNUM. */ |
| svn_revnum_t copyfrom_rev; |
| |
| /** The checksum of the node, if it is a file. */ |
| const svn_checksum_t *checksum; |
| |
| /** A changelist the item is in, @c NULL if this node is not in a |
| * changelist. */ |
| const char *changelist; |
| |
| /** The depth of the item, see #svn_depth_t */ |
| svn_depth_t depth; |
| |
| /** |
| * The size of the file after being translated into its local |
| * representation, or #SVN_INVALID_FILESIZE if unknown. |
| * Not applicable for directories. |
| */ |
| svn_filesize_t recorded_size; |
| |
| /** |
| * The time at which the file had the recorded size recorded_size and was |
| * considered unmodified. */ |
| apr_time_t recorded_time; |
| |
| /** Array of const svn_wc_conflict_description2_t * which contains info |
| * on any conflict of which this node is a victim. Otherwise NULL. */ |
| const apr_array_header_t *conflicts; |
| |
| /** The local absolute path of the working copy root. */ |
| const char *wcroot_abspath; |
| |
| /** The path the node was moved from, if it was moved here. Else NULL. |
| * @since New in 1.8. */ |
| const char *moved_from_abspath; |
| |
| /** The path the node was moved to, if it was moved away. Else NULL. |
| * @since New in 1.8. */ |
| const char *moved_to_abspath; |
| |
| /** |
| * The format of the working copy. |
| * @since New in 1.15. |
| */ |
| int wc_format; |
| |
| /** |
| * Whether pristine content is stored locally or is being fetched on-demand. |
| * @since New in 1.15. |
| */ |
| svn_boolean_t store_pristine; |
| } svn_wc_info_t; |
| |
| /** |
| * Return a duplicate of @a info, allocated in @a pool. No part of the new |
| * structure will be shared with @a info. |
| * |
| * @since New in 1.7. |
| */ |
| svn_wc_info_t * |
| svn_wc_info_dup(const svn_wc_info_t *info, |
| apr_pool_t *pool); |
| |
| |
| /** Given @a local_abspath in a dir under version control, decide if it is |
| * in a state of conflict; return the answers in @a *text_conflicted_p, @a |
| * *prop_conflicted_p, and @a *tree_conflicted_p. If one or two of the |
| * answers are uninteresting, simply pass @c NULL pointers for those. |
| * |
| * If @a local_abspath is unversioned or does not exist, return |
| * #SVN_ERR_WC_PATH_NOT_FOUND. |
| * |
| * If the @a local_abspath has corresponding text conflict files (with suffix |
| * .mine, .theirs, etc.) that cannot be found, assume that the text conflict |
| * has been resolved by the user and return @c FALSE in @a |
| * *text_conflicted_p. |
| * |
| * Similarly, if a property conflicts file (.prej suffix) is said to exist, |
| * but it cannot be found, assume that the property conflicts have been |
| * resolved by the user and return @c FALSE in @a *prop_conflicted_p. |
| * |
| * @a *tree_conflicted_p can't be auto-resolved in this fashion. An |
| * explicit `resolved' is needed. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_conflicted_p3(svn_boolean_t *text_conflicted_p, |
| svn_boolean_t *prop_conflicted_p, |
| svn_boolean_t *tree_conflicted_p, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_conflicted_p3(), but with a path/adm_access parameter |
| * pair in place of a wc_ctx/local_abspath pair. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_conflicted_p2(svn_boolean_t *text_conflicted_p, |
| svn_boolean_t *prop_conflicted_p, |
| svn_boolean_t *tree_conflicted_p, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| /** Given a @a dir_path under version control, decide if one of its entries |
| * (@a entry) is in a state of conflict; return the answers in @a |
| * text_conflicted_p and @a prop_conflicted_p. These pointers must not be |
| * null. |
| * |
| * If the @a entry mentions that text conflict files (with suffix .mine, |
| * .theirs, etc.) exist, but they cannot be found, assume the text conflict |
| * has been resolved by the user and return FALSE in @a *text_conflicted_p. |
| * |
| * Similarly, if the @a entry mentions that a property conflicts file (.prej |
| * suffix) exists, but it cannot be found, assume the property conflicts |
| * have been resolved by the user and return FALSE in @a *prop_conflicted_p. |
| * |
| * The @a entry is not updated. |
| * |
| * @deprecated Provided for backward compatibility with the 1.5 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_conflicted_p(svn_boolean_t *text_conflicted_p, |
| svn_boolean_t *prop_conflicted_p, |
| const char *dir_path, |
| const svn_wc_entry_t *entry, |
| apr_pool_t *pool); |
| |
| |
| /** Set @a *url and @a *rev to the ancestor URL and revision for @a path, |
| * allocating in @a pool. @a adm_access must be an access baton for @a path. |
| * |
| * If @a url or @a rev is NULL, then ignore it (just don't return the |
| * corresponding information). |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_ancestry(char **url, |
| svn_revnum_t *rev, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| |
| /** A callback vtable invoked by the generic entry-walker function. |
| * @since New in 1.5. |
| */ |
| typedef struct svn_wc_entry_callbacks2_t |
| { |
| /** An @a entry was found at @a path. */ |
| svn_error_t *(*found_entry)(const char *path, |
| const svn_wc_entry_t *entry, |
| void *walk_baton, |
| apr_pool_t *pool); |
| |
| /** Handle the error @a err encountered while processing @a path. |
| * Wrap or squelch @a err as desired, and return an #svn_error_t |
| * *, or #SVN_NO_ERROR. |
| */ |
| svn_error_t *(*handle_error)(const char *path, |
| svn_error_t *err, |
| void *walk_baton, |
| apr_pool_t *pool); |
| |
| } svn_wc_entry_callbacks2_t; |
| |
| /** @deprecated Provided for backward compatibility with the 1.4 API. */ |
| typedef struct svn_wc_entry_callbacks_t |
| { |
| /** An @a entry was found at @a path. */ |
| svn_error_t *(*found_entry)(const char *path, |
| const svn_wc_entry_t *entry, |
| void *walk_baton, |
| apr_pool_t *pool); |
| |
| } svn_wc_entry_callbacks_t; |
| |
| /** |
| * A generic entry-walker. |
| * |
| * Do a potentially recursive depth-first entry-walk beginning on |
| * @a path, which can be a file or dir. Call callbacks in |
| * @a walk_callbacks, passing @a walk_baton to each. Use @a pool for |
| * looping, recursion, and to allocate all entries returned. |
| * @a adm_access must be an access baton for @a path. The pool |
| * passed to @a walk_callbacks is a temporary subpool of @a pool. |
| * |
| * If @a depth is #svn_depth_empty, invoke the callbacks on @a path |
| * and return without recursing further. If #svn_depth_files, do |
| * the same and invoke the callbacks on file children (if any) of |
| * @a path, then return. If #svn_depth_immediates, do the preceding |
| * but also invoke callbacks on immediate subdirectories, then return. |
| * If #svn_depth_infinity, recurse fully starting from @a path. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine |
| * if the client has canceled the operation. |
| * |
| * Like our other entries interfaces, entries that are in a 'excluded', |
| * 'deleted' or 'absent' state (and not scheduled for re-addition) are not |
| * discovered, unless @a show_hidden is TRUE. Excluded entries are those with |
| * their depth set to #svn_depth_exclude. |
| * |
| * When a new directory is entered, #SVN_WC_ENTRY_THIS_DIR will always |
| * be returned first. |
| * |
| * @note Callers should be aware that each directory will be |
| * returned *twice*: first as an entry within its parent, and |
| * subsequently as the '.' entry within itself. The two calls can be |
| * distinguished by looking for #SVN_WC_ENTRY_THIS_DIR in the 'name' |
| * field of the entry. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_walk_entries3(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| const svn_wc_entry_callbacks2_t *walk_callbacks, |
| void *walk_baton, |
| svn_depth_t depth, |
| svn_boolean_t show_hidden, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_walk_entries3(), but without cancellation support |
| * or error handling from @a walk_callbacks, and with @a depth always |
| * set to #svn_depth_infinity. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_walk_entries2(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| const svn_wc_entry_callbacks_t *walk_callbacks, |
| void *walk_baton, |
| svn_boolean_t show_hidden, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_walk_entries2(), but without cancellation support. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_walk_entries(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| const svn_wc_entry_callbacks_t *walk_callbacks, |
| void *walk_baton, |
| svn_boolean_t show_hidden, |
| apr_pool_t *pool); |
| |
| |
| /** Mark missing @a path as 'deleted' in its @a parent's list of |
| * entries. @a path should be a directory that is both deleted (via |
| * svn_wc_delete4) and removed (via a system call). This function |
| * should only be called during post-commit processing following a |
| * successful commit editor drive. |
| * |
| * Return #SVN_ERR_WC_PATH_FOUND if @a path isn't actually missing. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_mark_missing_deleted(const char *path, |
| svn_wc_adm_access_t *parent, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Ensure that an administrative area exists for @a local_abspath, so |
| * that @a local_abspath is a working copy subdir based on @a url at @a |
| * revision, with depth @a depth, and with repository UUID @a repos_uuid |
| * and repository root URL @a repos_root_url. |
| * |
| * @a depth must be a definite depth, it cannot be #svn_depth_unknown. |
| * @a repos_uuid and @a repos_root_url MUST NOT be @c NULL, and |
| * @a repos_root_url must be a prefix of @a url. |
| * |
| * If the administrative area does not exist, then create it and |
| * initialize it to an unlocked state. The format of the new |
| * administrative area will be the library's default format |
| * (#SVN_WC__DEFAULT_VERSION). |
| * |
| * If the administrative area already exists then the given @a url |
| * must match the URL in the administrative area and the given |
| * @a revision must match the BASE of the working copy dir unless |
| * the admin directory is scheduled for deletion or the |
| * #SVN_ERR_WC_OBSTRUCTED_UPDATE error will be returned. |
| * |
| * Do not ensure existence of @a local_abspath itself; if @a local_abspath |
| * does not exist, return error. |
| * |
| * Use @a scratch_pool for temporary allocations. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backwards compatibility with the 1.14 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_ensure_adm4(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| const char *url, |
| const char *repos_root_url, |
| const char *repos_uuid, |
| svn_revnum_t revision, |
| svn_depth_t depth, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_ensure_adm4(), but without the wc context parameter. |
| * |
| * @note the @a uuid and @a repos parameters were documented as allowing |
| * @c NULL to be passed. Beginning with 1.7, this will return an error, |
| * contrary to prior documented behavior: see 'notes/api-errata/1.7/wc005.txt'. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backwards compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_ensure_adm3(const char *path, |
| const char *uuid, |
| const char *url, |
| const char *repos, |
| svn_revnum_t revision, |
| svn_depth_t depth, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Similar to svn_wc_ensure_adm3(), but with @a depth set to |
| * #svn_depth_infinity. |
| * |
| * See the note on svn_wc_ensure_adm3() regarding the @a repos and @a uuid |
| * parameters. |
| * |
| * @since New in 1.3. |
| * @deprecated Provided for backwards compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_ensure_adm2(const char *path, |
| const char *uuid, |
| const char *url, |
| const char *repos, |
| svn_revnum_t revision, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Similar to svn_wc_ensure_adm2(), but with @a repos set to @c NULL. |
| * |
| * @note as of 1.7, this function always returns #SVN_ERR_BAD_URL since |
| * the @a repos parameter may not be @c NULL. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.2 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_ensure_adm(const char *path, |
| const char *uuid, |
| const char *url, |
| svn_revnum_t revision, |
| apr_pool_t *pool); |
| |
| |
| /** Set the repository root URL of @a path to @a repos, if possible. |
| * |
| * Before Subversion 1.7 there could be working copy directories that |
| * didn't have a stored repository root in some specific circumstances. |
| * This function allowed setting this root later. |
| * |
| * Since Subversion 1.7 this function just returns #SVN_NO_ERROR. |
| * |
| * @since New in 1.3. |
| * @deprecated Provided for backwards compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_maybe_set_repos_root(svn_wc_adm_access_t *adm_access, |
| const char *path, |
| const char *repos, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * @defgroup svn_wc_status Working copy status. |
| * @{ |
| * |
| * We have three functions for getting working copy status: one function |
| * for getting the status of exactly one thing, another for |
| * getting the statuses of (potentially) multiple things and a third for |
| * getting the working copy out-of-dateness with respect to the repository. |
| * |
| * Why do we have two different functions for getting working copy status? |
| * The concept of depth, as explained in the documentation for |
| * svn_depth_t, may be useful in understanding this. Suppose we're |
| * getting the status of directory D: |
| * |
| * To offer all three levels, we could have one unified function, |
| * taking a `depth' parameter. Unfortunately, because this function |
| * would have to handle multiple return values as well as the single |
| * return value case, getting the status of just one entity would |
| * become cumbersome: you'd have to roll through a hash to find one |
| * lone status. |
| * |
| * So we have svn_wc_status3() for depth-empty (just D itself), and |
| * svn_wc_walk_status() for depth-immediates and depth-infinity, |
| * since the latter two involve multiple return values. And for |
| * out-of-dateness information we have svn_wc_get_status_editor5(). |
| */ |
| |
| /** The type of status for the working copy. */ |
| enum svn_wc_status_kind |
| { |
| /** does not exist */ |
| svn_wc_status_none = 1, |
| |
| /** is not a versioned thing in this wc */ |
| svn_wc_status_unversioned, |
| |
| /** exists, but uninteresting */ |
| svn_wc_status_normal, |
| |
| /** is scheduled for addition */ |
| svn_wc_status_added, |
| |
| /** under v.c., but is missing */ |
| svn_wc_status_missing, |
| |
| /** scheduled for deletion */ |
| svn_wc_status_deleted, |
| |
| /** was deleted and then re-added */ |
| svn_wc_status_replaced, |
| |
| /** text or props have been modified */ |
| svn_wc_status_modified, |
| |
| /** local mods received repos mods (### unused) */ |
| svn_wc_status_merged, |
| |
| /** local mods received conflicting repos mods */ |
| svn_wc_status_conflicted, |
| |
| /** is unversioned but configured to be ignored */ |
| svn_wc_status_ignored, |
| |
| /** an unversioned resource is in the way of the versioned resource */ |
| svn_wc_status_obstructed, |
| |
| /** an unversioned directory path populated by an svn:externals |
| property; this status is not used for file externals */ |
| svn_wc_status_external, |
| |
| /** a directory doesn't contain a complete entries list */ |
| svn_wc_status_incomplete |
| }; |
| |
| /** |
| * Structure for holding the "status" of a working copy item. |
| * |
| * @note Fields may be added to the end of this structure in future |
| * versions. Therefore, to preserve binary compatibility, users |
| * should not directly allocate structures of this type. |
| * |
| * @since New in 1.7. |
| */ |
| typedef struct svn_wc_status3_t |
| { |
| /** The kind of node as recorded in the working copy */ |
| svn_node_kind_t kind; |
| |
| /** The depth of the node as recorded in the working copy |
| * (#svn_depth_unknown for files or when no depth is set) */ |
| svn_depth_t depth; |
| |
| /** The actual size of the working file on disk, or SVN_INVALID_FILESIZE |
| * if unknown (or if the item isn't a file at all). */ |
| svn_filesize_t filesize; |
| |
| /** If the path is under version control, versioned is TRUE, otherwise |
| * FALSE. */ |
| svn_boolean_t versioned; |
| |
| /** Set to TRUE if the item is the victim of a conflict. */ |
| svn_boolean_t conflicted; |
| |
| /** The status of the node itself. In order of precedence: Obstructions, |
| * structural changes, text changes. */ |
| enum svn_wc_status_kind node_status; |
| |
| /** The status of the entry's text. */ |
| enum svn_wc_status_kind text_status; |
| |
| /** The status of the entry's properties. */ |
| enum svn_wc_status_kind prop_status; |
| |
| /** a file or directory can be 'copied' if it's scheduled for |
| * addition-with-history (or part of a subtree that is scheduled as such.). |
| */ |
| svn_boolean_t copied; |
| |
| /** Base revision. */ |
| svn_revnum_t revision; |
| |
| /** Last revision this was changed */ |
| svn_revnum_t changed_rev; |
| |
| /** Date of last commit. */ |
| apr_time_t changed_date; |
| |
| /** Last commit author of this item */ |
| const char *changed_author; |
| |
| /** The URL of the repository */ |
| const char *repos_root_url; |
| |
| /** The UUID of the repository */ |
| const char *repos_uuid; |
| |
| /** The in-repository path relative to the repository root. */ |
| const char *repos_relpath; |
| |
| /** a file or directory can be 'switched' if the switch command has been |
| * used. If this is TRUE, then file_external will be FALSE. |
| */ |
| svn_boolean_t switched; |
| |
| /** This directory has a working copy lock */ |
| svn_boolean_t locked; |
| |
| /** The repository file lock. (Values of path, token, owner, comment |
| * and are available if a lock is present) */ |
| const svn_lock_t *lock; |
| |
| /** Which changelist this item is part of, or NULL if not part of any. */ |
| const char *changelist; |
| |
| /** |
| * @defgroup svn_wc_status_ood WC out-of-date info from the repository |
| * @{ |
| * |
| * When the working copy item is out-of-date compared to the |
| * repository, the following fields represent the state of the |
| * youngest revision of the item in the repository. If the working |
| * copy is not out of date, the fields are initialized as described |
| * below. |
| */ |
| |
| /** Set to the node kind of the youngest commit, or #svn_node_none |
| * if not out of date. */ |
| svn_node_kind_t ood_kind; |
| |
| /** The status of the node, based on the text status if the node has no |
| * restructuring changes */ |
| enum svn_wc_status_kind repos_node_status; |
| |
| /** The entry's text status in the repository. */ |
| enum svn_wc_status_kind repos_text_status; |
| |
| /** The entry's property status in the repository. */ |
| enum svn_wc_status_kind repos_prop_status; |
| |
| /** The entry's lock in the repository, if any. */ |
| const svn_lock_t *repos_lock; |
| |
| /** Set to the youngest committed revision, or #SVN_INVALID_REVNUM |
| * if not out of date. */ |
| svn_revnum_t ood_changed_rev; |
| |
| /** Set to the most recent commit date, or @c 0 if not out of date. */ |
| apr_time_t ood_changed_date; |
| |
| /** Set to the user name of the youngest commit, or @c NULL if not |
| * out of date or non-existent. Because a non-existent @c |
| * svn:author property has the same behavior as an out-of-date |
| * working copy, examine @c ood_last_cmt_rev to determine whether |
| * the working copy is out of date. */ |
| const char *ood_changed_author; |
| |
| /** @} */ |
| |
| /** Set to the local absolute path that this node was moved from, if this |
| * file or directory has been moved here locally and is the root of that |
| * move. Otherwise set to NULL. |
| * |
| * This will be NULL for moved-here nodes that are just part of a subtree |
| * that was moved along (and are not themselves a root of a different move |
| * operation). |
| * |
| * @since New in 1.8. */ |
| const char *moved_from_abspath; |
| |
| /** Set to the local absolute path that this node was moved to, if this file |
| * or directory has been moved away locally and corresponds to the root |
| * of the destination side of the move. Otherwise set to NULL. |
| * |
| * Note: Saying just "root" here could be misleading. For example: |
| * svn mv A AA; |
| * svn mv AA/B BB; |
| * creates a situation where A/B is moved-to BB, but one could argue that |
| * the move source's root actually was AA/B. Note that, as far as the |
| * working copy is concerned, above case is exactly identical to: |
| * svn mv A/B BB; |
| * svn mv A AA; |
| * In both situations, @a moved_to_abspath would be set for nodes A (moved |
| * to AA) and A/B (moved to BB), only. |
| * |
| * This will be NULL for moved-away nodes that were just part of a subtree |
| * that was moved along (and are not themselves a root of a different move |
| * operation). |
| * |
| * @since New in 1.8. */ |
| const char *moved_to_abspath; |
| |
| /** @c TRUE iff the item is a file brought in by an svn:externals definition. |
| * @since New in 1.8. */ |
| svn_boolean_t file_external; |
| |
| |
| /** The actual kind of the node in the working copy. May differ from |
| * @a kind on obstructions, deletes, etc. #svn_node_unknown if unavailable. |
| * |
| * @since New in 1.9 */ |
| svn_node_kind_t actual_kind; |
| |
| /* NOTE! Please update svn_wc_dup_status3() when adding new fields here. */ |
| } svn_wc_status3_t; |
| |
| /** |
| * ### All diffs are not yet known. |
| * Same as svn_wc_status3_t, but without the #svn_boolean_t 'versioned' |
| * field. Instead an item that is not versioned has the 'entry' field set to |
| * @c NULL. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| typedef struct svn_wc_status2_t |
| { |
| /** Can be @c NULL if not under version control. */ |
| const svn_wc_entry_t *entry; |
| |
| /** The status of the entry itself, including its text if it is a file. */ |
| enum svn_wc_status_kind text_status; |
| |
| /** The status of the entry's properties. */ |
| enum svn_wc_status_kind prop_status; |
| |
| /** a directory can be 'locked' if a working copy update was interrupted. */ |
| svn_boolean_t locked; |
| |
| /** a file or directory can be 'copied' if it's scheduled for |
| * addition-with-history (or part of a subtree that is scheduled as such.). |
| */ |
| svn_boolean_t copied; |
| |
| /** a file or directory can be 'switched' if the switch command has been |
| * used. If this is TRUE, then file_external will be FALSE. |
| */ |
| svn_boolean_t switched; |
| |
| /** The entry's text status in the repository. */ |
| enum svn_wc_status_kind repos_text_status; |
| |
| /** The entry's property status in the repository. */ |
| enum svn_wc_status_kind repos_prop_status; |
| |
| /** The entry's lock in the repository, if any. */ |
| svn_lock_t *repos_lock; |
| |
| /** Set to the URI (actual or expected) of the item. |
| * @since New in 1.3 |
| */ |
| const char *url; |
| |
| /** |
| * @defgroup svn_wc_status_ood WC out-of-date info from the repository |
| * @{ |
| * |
| * When the working copy item is out-of-date compared to the |
| * repository, the following fields represent the state of the |
| * youngest revision of the item in the repository. If the working |
| * copy is not out of date, the fields are initialized as described |
| * below. |
| */ |
| |
| /** Set to the youngest committed revision, or #SVN_INVALID_REVNUM |
| * if not out of date. |
| * @since New in 1.3 |
| */ |
| svn_revnum_t ood_last_cmt_rev; |
| |
| /** Set to the most recent commit date, or @c 0 if not out of date. |
| * @since New in 1.3 |
| */ |
| apr_time_t ood_last_cmt_date; |
| |
| /** Set to the node kind of the youngest commit, or #svn_node_none |
| * if not out of date. |
| * @since New in 1.3 |
| */ |
| svn_node_kind_t ood_kind; |
| |
| /** Set to the user name of the youngest commit, or @c NULL if not |
| * out of date or non-existent. Because a non-existent @c |
| * svn:author property has the same behavior as an out-of-date |
| * working copy, examine @c ood_last_cmt_rev to determine whether |
| * the working copy is out of date. |
| * @since New in 1.3 |
| */ |
| const char *ood_last_cmt_author; |
| |
| /** @} */ |
| |
| /** Non-NULL if the entry is the victim of a tree conflict. |
| * @since New in 1.6 |
| */ |
| svn_wc_conflict_description_t *tree_conflict; |
| |
| /** If the item is a file that was added to the working copy with an |
| * svn:externals; if file_external is TRUE, then switched is always |
| * FALSE. |
| * @since New in 1.6 |
| */ |
| svn_boolean_t file_external; |
| |
| /** The actual status of the text compared to the pristine base of the |
| * file. This value isn't masked by other working copy statuses. |
| * @c pristine_text_status is #svn_wc_status_none if this value was |
| * not calculated during the status walk. |
| * @since New in 1.6 |
| */ |
| enum svn_wc_status_kind pristine_text_status; |
| |
| /** The actual status of the properties compared to the pristine base of |
| * the node. This value isn't masked by other working copy statuses. |
| * @c pristine_prop_status is #svn_wc_status_none if this value was |
| * not calculated during the status walk. |
| * @since New in 1.6 |
| */ |
| enum svn_wc_status_kind pristine_prop_status; |
| |
| } svn_wc_status2_t; |
| |
| |
| |
| /** |
| * Same as #svn_wc_status2_t, but without the #svn_lock_t 'repos_lock', const char 'url', #svn_revnum_t 'ood_last_cmt_rev', apr_time_t 'ood_last_cmt_date', #svn_node_kind_t 'ood_kind', const char 'ood_last_cmt_author', #svn_wc_conflict_description_t 'tree_conflict', #svn_boolean_t 'file_external', #svn_wc_status_kind 'pristine_text_status', and #svn_wc_status_kind 'pristine_prop_status' fields. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| typedef struct svn_wc_status_t |
| { |
| /** Can be @c NULL if not under version control. */ |
| const svn_wc_entry_t *entry; |
| |
| /** The status of the entries text. */ |
| enum svn_wc_status_kind text_status; |
| |
| /** The status of the entries properties. */ |
| enum svn_wc_status_kind prop_status; |
| |
| /** a directory can be 'locked' if a working copy update was interrupted. */ |
| svn_boolean_t locked; |
| |
| /** a file or directory can be 'copied' if it's scheduled for |
| * addition-with-history (or part of a subtree that is scheduled as such.). |
| */ |
| svn_boolean_t copied; |
| |
| /** a file or directory can be 'switched' if the switch command has been |
| * used. |
| */ |
| svn_boolean_t switched; |
| |
| /** The entry's text status in the repository. */ |
| enum svn_wc_status_kind repos_text_status; |
| |
| /** The entry's property status in the repository. */ |
| enum svn_wc_status_kind repos_prop_status; |
| |
| } svn_wc_status_t; |
| |
| |
| /** |
| * Return a deep copy of the @a orig_stat status structure, allocated |
| * in @a pool. |
| * |
| * @since New in 1.7. |
| */ |
| svn_wc_status3_t * |
| svn_wc_dup_status3(const svn_wc_status3_t *orig_stat, |
| apr_pool_t *pool); |
| |
| /** |
| * Same as svn_wc_dup_status3(), but for older svn_wc_status_t structures. |
| * |
| * @since New in 1.2 |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_wc_status2_t * |
| svn_wc_dup_status2(const svn_wc_status2_t *orig_stat, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Same as svn_wc_dup_status2(), but for older svn_wc_status_t structures. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_wc_status_t * |
| svn_wc_dup_status(const svn_wc_status_t *orig_stat, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Fill @a *status for @a local_abspath, allocating in @a result_pool. |
| * Use @a scratch_pool for temporary allocations. |
| * |
| * Here are some things to note about the returned structure. A quick |
| * examination of the @c status->text_status after a successful return of |
| * this function can reveal the following things: |
| * |
| * - #svn_wc_status_none : @a local_abspath is not versioned, and is |
| * not present on disk |
| * |
| * - #svn_wc_status_missing : @a local_abspath is versioned, but is |
| * missing from the working copy. |
| * |
| * - #svn_wc_status_unversioned : @a local_abspath is not versioned, |
| * but is present on disk and not being |
| * ignored (see above). |
| * |
| * The other available results for the @c text_status field are more |
| * straightforward in their meanings. See the comments on the |
| * #svn_wc_status_kind structure for some hints. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_status3(svn_wc_status3_t **status, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_status3(), but with a adm_access baton and absolute |
| * path. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_status2(svn_wc_status2_t **status, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Same as svn_wc_status2(), but for older svn_wc_status_t structures. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_status(svn_wc_status_t **status, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| |
| |
| |
| /** |
| * A callback for reporting a @a status about @a local_abspath. |
| * |
| * @a baton is a closure object; it should be provided by the |
| * implementation, and passed by the caller. |
| * |
| * @a scratch_pool will be cleared between invocations to the callback. |
| * |
| * @since New in 1.7. |
| */ |
| typedef svn_error_t *(*svn_wc_status_func4_t)(void *baton, |
| const char *local_abspath, |
| const svn_wc_status3_t *status, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Same as svn_wc_status_func4_t, but with a non-const status and a relative |
| * path. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| typedef svn_error_t *(*svn_wc_status_func3_t)(void *baton, |
| const char *path, |
| svn_wc_status2_t *status, |
| apr_pool_t *pool); |
| |
| /** |
| * Same as svn_wc_status_func3_t, but without a provided pool or |
| * the ability to propagate errors. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.5 API. |
| */ |
| typedef void (*svn_wc_status_func2_t)(void *baton, |
| const char *path, |
| svn_wc_status2_t *status); |
| |
| /** |
| * Same as svn_wc_status_func2_t, but for older svn_wc_status_t structures. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| typedef void (*svn_wc_status_func_t)(void *baton, |
| const char *path, |
| svn_wc_status_t *status); |
| |
| /** |
| * Walk the working copy status of @a local_abspath using @a wc_ctx, by |
| * creating #svn_wc_status3_t structures and sending these through |
| * @a status_func / @a status_baton. |
| * |
| * * Assuming the target is a directory, then: |
| * |
| * - If @a get_all is FALSE, then only locally-modified entries will be |
| * returned. If TRUE, then all entries will be returned. |
| * |
| * - If @a ignore_text_mods is TRUE, then the walk will not check for |
| * modified files. Any #svn_wc_status3_t structures returned for files |
| * will always have a text_status field set to svn_wc_status_normal. |
| * If @a ignore_text_mods is FALSE, the walk checks for text changes |
| * and returns #svn_wc_status3_t structures describing any changes. |
| * |
| * - If @a depth is #svn_depth_empty, a status structure will |
| * be returned for the target only; if #svn_depth_files, for the |
| * target and its immediate file children; if |
| * #svn_depth_immediates, for the target and its immediate |
| * children; if #svn_depth_infinity, for the target and |
| * everything underneath it, fully recursively. |
| * |
| * If @a depth is #svn_depth_unknown, take depths from the |
| * working copy and behave as above in each directory's case. |
| * |
| * If the given @a depth is incompatible with the depth found in a |
| * working copy directory, the found depth always governs. |
| * |
| * If @a no_ignore is set, statuses that would typically be ignored |
| * will instead be reported. |
| * |
| * @a ignore_patterns is an array of file patterns matching |
| * unversioned files to ignore for the purposes of status reporting, |
| * or @c NULL if the default set of ignorable file patterns should be used. |
| * Patterns from #SVN_PROP_IGNORE (and, as of 1.8, |
| * #SVN_PROP_INHERITABLE_IGNORES) properties are always used, even if not |
| * specified in @a ignore_patterns. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton while walking |
| * to determine if the client has canceled the operation. |
| * |
| * This function uses @a scratch_pool for temporary allocations. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_walk_status(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_depth_t depth, |
| svn_boolean_t get_all, |
| svn_boolean_t no_ignore, |
| svn_boolean_t ignore_text_mods, |
| const apr_array_header_t *ignore_patterns, |
| svn_wc_status_func4_t status_func, |
| void *status_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * DEPRECATED -- please use APIs from svn_client.h |
| * |
| * --- |
| * |
| * Set @a *editor and @a *edit_baton to an editor that generates |
| * #svn_wc_status3_t structures and sends them through @a status_func / |
| * @a status_baton. @a anchor_abspath is a working copy directory |
| * directory which will be used as the root of our editor. If @a |
| * target_basename is not "", it represents a node in the @a anchor_abspath |
| * which is the subject of the editor drive (otherwise, the @a |
| * anchor_abspath is the subject). |
| * |
| * If @a set_locks_baton is non-@c NULL, it will be set to a baton that can |
| * be used in a call to the svn_wc_status_set_repos_locks() function. |
| * |
| * Callers drive this editor to describe working copy out-of-dateness |
| * with respect to the repository. If this information is not |
| * available or not desired, callers should simply call the |
| * close_edit() function of the @a editor vtable. |
| * |
| * If the editor driver calls @a editor's set_target_revision() vtable |
| * function, then when the edit drive is completed, @a *edit_revision |
| * will contain the revision delivered via that interface. |
| * |
| * Assuming the target is a directory, then: |
| * |
| * - If @a get_all is FALSE, then only locally-modified entries will be |
| * returned. If TRUE, then all entries will be returned. |
| * |
| * - If @a depth is #svn_depth_empty, a status structure will |
| * be returned for the target only; if #svn_depth_files, for the |
| * target and its immediate file children; if |
| * #svn_depth_immediates, for the target and its immediate |
| * children; if #svn_depth_infinity, for the target and |
| * everything underneath it, fully recursively. |
| * |
| * If @a depth is #svn_depth_unknown, take depths from the |
| * working copy and behave as above in each directory's case. |
| * |
| * If the given @a depth is incompatible with the depth found in a |
| * working copy directory, the found depth always governs. |
| * |
| * If @a no_ignore is set, statuses that would typically be ignored |
| * will instead be reported. |
| * |
| * @a ignore_patterns is an array of file patterns matching |
| * unversioned files to ignore for the purposes of status reporting, |
| * or @c NULL if the default set of ignorable file patterns should be used. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton while building |
| * the @a statushash to determine if the client has canceled the operation. |
| * |
| * If @a depth_as_sticky is set handle @a depth like when depth_is_sticky is |
| * passed for updating. This will show excluded nodes show up as added in the |
| * repository. |
| * |
| * If @a server_performs_filtering is TRUE, assume that the server handles |
| * the ambient depth filtering, so this doesn't have to be handled in the |
| * editor. |
| * |
| * Allocate the editor itself in @a result_pool, and use @a scratch_pool |
| * for temporary allocations. The editor will do its temporary allocations |
| * in a subpool of @a result_pool. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_status_editor5(const svn_delta_editor_t **editor, |
| void **edit_baton, |
| void **set_locks_baton, |
| svn_revnum_t *edit_revision, |
| svn_wc_context_t *wc_ctx, |
| const char *anchor_abspath, |
| const char *target_basename, |
| svn_depth_t depth, |
| svn_boolean_t get_all, |
| svn_boolean_t no_ignore, |
| svn_boolean_t depth_as_sticky, |
| svn_boolean_t server_performs_filtering, |
| const apr_array_header_t *ignore_patterns, |
| svn_wc_status_func4_t status_func, |
| void *status_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Same as svn_wc_get_status_editor5, but using #svn_wc_status_func3_t |
| * instead of #svn_wc_status_func4_t. And @a server_performs_filtering |
| * always set to #TRUE. |
| * |
| * This also uses a single pool parameter, stating that all temporary |
| * allocations are performed in manually constructed/destroyed subpool. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_status_editor4(const svn_delta_editor_t **editor, |
| void **edit_baton, |
| void **set_locks_baton, |
| svn_revnum_t *edit_revision, |
| svn_wc_adm_access_t *anchor, |
| const char *target, |
| svn_depth_t depth, |
| svn_boolean_t get_all, |
| svn_boolean_t no_ignore, |
| const apr_array_header_t *ignore_patterns, |
| svn_wc_status_func3_t status_func, |
| void *status_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_traversal_info_t *traversal_info, |
| apr_pool_t *pool); |
| |
| /** |
| * Same as svn_wc_get_status_editor4(), but using #svn_wc_status_func2_t |
| * instead of #svn_wc_status_func3_t. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backward compatibility with the 1.5 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_status_editor3(const svn_delta_editor_t **editor, |
| void **edit_baton, |
| void **set_locks_baton, |
| svn_revnum_t *edit_revision, |
| svn_wc_adm_access_t *anchor, |
| const char *target, |
| svn_depth_t depth, |
| svn_boolean_t get_all, |
| svn_boolean_t no_ignore, |
| const apr_array_header_t *ignore_patterns, |
| svn_wc_status_func2_t status_func, |
| void *status_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_traversal_info_t *traversal_info, |
| apr_pool_t *pool); |
| |
| /** |
| * Like svn_wc_get_status_editor3(), but with @a ignore_patterns |
| * provided from the corresponding value in @a config, and @a recurse |
| * instead of @a depth. If @a recurse is TRUE, behave as if for |
| * #svn_depth_infinity; else if @a recurse is FALSE, behave as if for |
| * #svn_depth_immediates. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_status_editor2(const svn_delta_editor_t **editor, |
| void **edit_baton, |
| void **set_locks_baton, |
| svn_revnum_t *edit_revision, |
| svn_wc_adm_access_t *anchor, |
| const char *target, |
| apr_hash_t *config, |
| svn_boolean_t recurse, |
| svn_boolean_t get_all, |
| svn_boolean_t no_ignore, |
| svn_wc_status_func2_t status_func, |
| void *status_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_traversal_info_t *traversal_info, |
| apr_pool_t *pool); |
| |
| /** |
| * Same as svn_wc_get_status_editor2(), but with @a set_locks_baton set |
| * to @c NULL, and taking a deprecated svn_wc_status_func_t argument. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_status_editor(const svn_delta_editor_t **editor, |
| void **edit_baton, |
| svn_revnum_t *edit_revision, |
| svn_wc_adm_access_t *anchor, |
| const char *target, |
| apr_hash_t *config, |
| svn_boolean_t recurse, |
| svn_boolean_t get_all, |
| svn_boolean_t no_ignore, |
| svn_wc_status_func_t status_func, |
| void *status_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_traversal_info_t *traversal_info, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Associate @a locks, a hash table mapping <tt>const char*</tt> |
| * absolute repository paths to <tt>svn_lock_t</tt> objects, with a |
| * @a set_locks_baton returned by an earlier call to |
| * svn_wc_get_status_editor3(). @a repos_root is the repository root URL. |
| * Perform all allocations in @a pool. |
| * |
| * @note @a locks will not be copied, so it must be valid throughout the |
| * edit. @a pool must also not be destroyed or cleared before the edit is |
| * finished. |
| * |
| * @since New in 1.2. |
| */ |
| svn_error_t * |
| svn_wc_status_set_repos_locks(void *set_locks_baton, |
| apr_hash_t *locks, |
| const char *repos_root, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** |
| * Copy @a src_abspath to @a dst_abspath, and schedule @a dst_abspath |
| * for addition to the repository, remembering the copy history. @a wc_ctx |
| * is used for accessing the working copy and must contain a write lock for |
| * the parent directory of @a dst_abspath, |
| * |
| * If @a metadata_only is TRUE then this is a database-only operation and |
| * the working directories and files are not copied. |
| * |
| * @a src_abspath must be a file or directory under version control; |
| * the parent of @a dst_abspath must be a directory under version control |
| * in the same working copy; @a dst_abspath will be the name of the copied |
| * item, and it must not exist already if @a metadata_only is FALSE. Note that |
| * when @a src points to a versioned file, the working file doesn't |
| * necessarily exist in which case its text-base is used instead. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton at |
| * various points during the operation. If it returns an error |
| * (typically #SVN_ERR_CANCELLED), return that error immediately. |
| * |
| * If @a notify_func is non-NULL, call it with @a notify_baton and the path |
| * of the root node (only) of the destination. |
| * |
| * Use @a scratch_pool for temporary allocations. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_copy3(svn_wc_context_t *wc_ctx, |
| const char *src_abspath, |
| const char *dst_abspath, |
| svn_boolean_t metadata_only, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_copy3(), but takes access batons and a relative path |
| * and a basename instead of absolute paths and a working copy context. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_copy2(const char *src, |
| svn_wc_adm_access_t *dst_parent, |
| const char *dst_basename, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_copy2(), but takes an #svn_wc_notify_func_t instead. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_copy(const char *src, |
| svn_wc_adm_access_t *dst_parent, |
| const char *dst_basename, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Move @a src_abspath to @a dst_abspath, by scheduling @a dst_abspath |
| * for addition to the repository, remembering the history. Mark @a src_abspath |
| * as deleted after moving.@a wc_ctx is used for accessing the working copy and |
| * must contain a write lock for the parent directory of @a src_abspath and |
| * @a dst_abspath. |
| * |
| * If @a metadata_only is TRUE then this is a database-only operation and |
| * the working directories and files are not changed. |
| * |
| * @a src_abspath must be a file or directory under version control; |
| * the parent of @a dst_abspath must be a directory under version control |
| * in the same working copy; @a dst_abspath will be the name of the copied |
| * item, and it must not exist already if @a metadata_only is FALSE. Note that |
| * when @a src points to a versioned file, the working file doesn't |
| * necessarily exist in which case its text-base is used instead. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton at |
| * various points during the operation. If it returns an error |
| * (typically #SVN_ERR_CANCELLED), return that error immediately. |
| * |
| * If @a notify_func is non-NULL, call it with @a notify_baton and the path |
| * of the root node (only) of the destination. |
| * |
| * Use @a scratch_pool for temporary allocations. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.7 API. |
| * @see svn_client_move7() |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_move(svn_wc_context_t *wc_ctx, |
| const char *src_abspath, |
| const char *dst_abspath, |
| svn_boolean_t metadata_only, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Schedule @a local_abspath for deletion. It will be deleted from the |
| * repository on the next commit. If @a local_abspath refers to a |
| * directory, then a recursive deletion will occur. @a wc_ctx must hold |
| * a write lock for the parent of @a local_abspath, @a local_abspath itself |
| * and everything below @a local_abspath. |
| * |
| * If @a keep_local is FALSE, this function immediately deletes all files, |
| * modified and unmodified, versioned and if @a delete_unversioned is TRUE, |
| * unversioned from the working copy. |
| * It also immediately deletes unversioned directories and directories that |
| * are scheduled to be added below @a local_abspath. Only versioned may |
| * remain in the working copy, these get deleted by the update following |
| * the commit. |
| * |
| * If @a keep_local is TRUE, all files and directories will be kept in the |
| * working copy (and will become unversioned on the next commit). |
| * |
| * If @a delete_unversioned_target is TRUE and @a local_abspath is not |
| * versioned, @a local_abspath will be handled as an added files without |
| * history. So it will be deleted if @a keep_local is FALSE. If @a |
| * delete_unversioned is FALSE and @a local_abspath is not versioned a |
| * #SVN_ERR_WC_PATH_NOT_FOUND error will be returned. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton at |
| * various points during the operation. If it returns an error |
| * (typically #SVN_ERR_CANCELLED), return that error immediately. |
| * |
| * For each path marked for deletion, @a notify_func will be called with |
| * the @a notify_baton and that path. The @a notify_func callback may be |
| * @c NULL if notification is not needed. |
| * |
| * Use @a scratch_pool for temporary allocations. It may be cleared |
| * immediately upon returning from this function. |
| * |
| * @since New in 1.7. |
| */ |
| /* ### BH: Maybe add a delete_switched flag that allows deny switched |
| nodes like file externals? */ |
| svn_error_t * |
| svn_wc_delete4(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_boolean_t keep_local, |
| svn_boolean_t delete_unversioned_target, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_delete4, but uses an access baton and relative path |
| * instead of a working copy context and absolute path. @a adm_access |
| * must hold a write lock for the parent of @a path. |
| * |
| * @c delete_unversioned_target will always be set to TRUE. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_delete3(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| svn_boolean_t keep_local, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_delete3(), but with @a keep_local always set to FALSE. |
| * |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_delete2(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_delete2(), but takes an #svn_wc_notify_func_t instead. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_delete(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Schedule the single node that exists on disk at @a local_abspath for |
| * addition to the working copy. The added node will have the properties |
| * provided in @a props, or none if that is NULL. |
| * |
| * Unless @a skip_checks is TRUE, check and canonicalize the properties in the |
| * same way as svn_wc_prop_set4(). Return an error and don't add the node if |
| * the properties are not valid on this node. |
| * |
| * ### The error code on validity check failure should be specified, and |
| * preferably should be a single code. |
| * |
| * The versioned state of the parent path must be a modifiable directory, |
| * and the versioned state of @a local_abspath must be either nonexistent or |
| * deleted; if deleted, the new node will be a replacement. |
| * |
| * If @a local_abspath does not exist as file, directory or symlink, return |
| * #SVN_ERR_WC_PATH_NOT_FOUND. |
| * |
| * If @a notify_func is non-NULL, invoke it with @a notify_baton to report |
| * the item being added. |
| * |
| * ### TODO: Split into add_dir, add_file, add_symlink? |
| * |
| * @since New in 1.9. |
| */ |
| svn_error_t * |
| svn_wc_add_from_disk3(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| const apr_hash_t *props, |
| svn_boolean_t skip_checks, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_add_from_disk3(), but always passes FALSE for |
| * @a skip_checks |
| * |
| * @since New in 1.8. |
| * @deprecated Provided for backward compatibility with the 1.8 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_add_from_disk2(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| const apr_hash_t *props, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** |
| * Similar to svn_wc_add_from_disk2(), but always passes NULL for @a |
| * props. |
| * |
| * This is a replacement for svn_wc_add4() case 2a (which see for |
| * details). |
| |
| * @see svn_wc_add4() |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_add_from_disk(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** |
| * Put @a local_abspath under version control by registering it as addition |
| * or copy in the database containing its parent. The new node is scheduled |
| * for addition to the repository below its parent node. |
| * |
| * 1) If the node is already versioned, it MUST BE the root of a separate |
| * working copy from the same repository as the parent WC. The new node |
| * and anything below it will be scheduled for addition inside the parent |
| * working copy as a copy of the original location. The separate working |
| * copy will be integrated by this step. In this case, which is only used |
| * by code like that of "svn cp URL@rev path" @a copyfrom_url and |
| * @a copyfrom_rev MUST BE the url and revision of @a local_abspath |
| * in the separate working copy. |
| * |
| * 2a) If the node was not versioned before it will be scheduled as a local |
| * addition or 2b) if @a copyfrom_url and @a copyfrom_rev are set as a copy |
| * of that location. In this last case the function doesn't set the pristine |
| * version (of a file) and/or pristine properties, which callers should |
| * handle via different APIs. Usually it is easier to call |
| * svn_wc_add_repos_file4() (### or a possible svn_wc_add_repos_dir()) than |
| * using this variant. |
| * |
| * If @a local_abspath does not exist as file, directory or symlink, return |
| * #SVN_ERR_WC_PATH_NOT_FOUND. |
| * |
| * If @a local_abspath is an unversioned directory, record @a depth on it; |
| * otherwise, ignore @a depth. (Use #svn_depth_infinity unless you exactly |
| * know what you are doing, or you may create an unexpected sparse working |
| * copy) |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton at |
| * various points during the operation. If it returns an error |
| * (typically #SVN_ERR_CANCELLED), return that error immediately. |
| * |
| * When the @a local_abspath has been added, then @a notify_func will be |
| * called (if it is not @c NULL) with the @a notify_baton and the path. |
| * |
| * @note Case 1 is deprecated. Consider doing a WC-to-WC copy instead. |
| * @note For case 2a, prefer svn_wc_add_from_disk(). |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_add4(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_depth_t depth, |
| const char *copyfrom_url, |
| svn_revnum_t copyfrom_rev, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_add4(), but with an access baton |
| * and relative path instead of a context and absolute path. |
| * @since New in 1.6. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_add3(const char *path, |
| svn_wc_adm_access_t *parent_access, |
| svn_depth_t depth, |
| const char *copyfrom_url, |
| svn_revnum_t copyfrom_rev, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_add3(), but with the @a depth parameter always |
| * #svn_depth_infinity. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.5 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_add2(const char *path, |
| svn_wc_adm_access_t *parent_access, |
| const char *copyfrom_url, |
| svn_revnum_t copyfrom_rev, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_add2(), but takes an #svn_wc_notify_func_t instead. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_add(const char *path, |
| svn_wc_adm_access_t *parent_access, |
| const char *copyfrom_url, |
| svn_revnum_t copyfrom_rev, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| /** Add a file to a working copy at @a local_abspath, obtaining the |
| * text-base's contents from @a new_base_contents, the wc file's |
| * content from @a new_contents, its unmodified properties from @a |
| * new_base_props and its actual properties from @a new_props. Use |
| * @a wc_ctx for accessing the working copy. |
| * |
| * The unmodified text and props normally come from the repository |
| * file represented by the copyfrom args, see below. The new file |
| * will be marked as copy. |
| * |
| * @a new_contents and @a new_props may be NULL, in which case |
| * the working copy text and props are taken from the base files with |
| * appropriate translation of the file's content. |
| * |
| * @a new_contents must be provided in Normal Form. This is required |
| * in order to pass both special and non-special files through a stream. |
| * |
| * @a wc_ctx must contain a write lock for the parent of @a local_abspath. |
| * |
| * If @a copyfrom_url is non-NULL, then @a copyfrom_rev must be a |
| * valid revision number, and together they are the copyfrom history |
| * for the new file. |
| * |
| * The @a cancel_func and @a cancel_baton are a standard cancellation |
| * callback, or NULL if no callback is needed. @a notify_func and |
| * @a notify_baton are a notification callback, and (if not NULL) |
| * will be notified of the addition of this file. |
| * |
| * Use @a scratch_pool for temporary allocations. |
| * |
| * ### This function is very redundant with svn_wc_add(). Ideally, |
| * we'd merge them, so that svn_wc_add() would just take optional |
| * new_props and optional copyfrom information. That way it could be |
| * used for both 'svn add somefilesittingonmydisk' and for adding |
| * files from repositories, with or without copyfrom history. |
| * |
| * The problem with this Ideal Plan is that svn_wc_add() also takes |
| * care of recursive URL-rewriting. There's a whole comment in its |
| * doc string about how that's really weird, outside its core mission, |
| * etc, etc. So another part of the Ideal Plan is that that |
| * functionality of svn_wc_add() would move into a separate function. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_add_repos_file4(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_stream_t *new_base_contents, |
| svn_stream_t *new_contents, |
| apr_hash_t *new_base_props, |
| apr_hash_t *new_props, |
| const char *copyfrom_url, |
| svn_revnum_t copyfrom_rev, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_add_repos_file4, but uses access batons and a |
| * relative path instead of a working copy context and absolute path. |
| * |
| * ### NOTE: the notification callback/baton is not yet used. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_add_repos_file3(const char *dst_path, |
| svn_wc_adm_access_t *adm_access, |
| svn_stream_t *new_base_contents, |
| svn_stream_t *new_contents, |
| apr_hash_t *new_base_props, |
| apr_hash_t *new_props, |
| const char *copyfrom_url, |
| svn_revnum_t copyfrom_rev, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Same as svn_wc_add_repos_file3(), except that it has pathnames rather |
| * than streams for the text base, and actual text, and has no cancellation. |
| * |
| * @since New in 1.4. |
| * @deprecated Provided for compatibility with the 1.5 API |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_add_repos_file2(const char *dst_path, |
| svn_wc_adm_access_t *adm_access, |
| const char *new_text_base_path, |
| const char *new_text_path, |
| apr_hash_t *new_base_props, |
| apr_hash_t *new_props, |
| const char *copyfrom_url, |
| svn_revnum_t copyfrom_rev, |
| apr_pool_t *pool); |
| |
| /** Same as svn_wc_add_repos_file3(), except that it doesn't have the |
| * BASE arguments or cancellation. |
| * |
| * @deprecated Provided for compatibility with the 1.3 API |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_add_repos_file(const char *dst_path, |
| svn_wc_adm_access_t *adm_access, |
| const char *new_text_path, |
| apr_hash_t *new_props, |
| const char *copyfrom_url, |
| svn_revnum_t copyfrom_rev, |
| apr_pool_t *pool); |
| |
| |
| /** Remove @a local_abspath from revision control. @a wc_ctx must |
| * hold a write lock on the parent of @a local_abspath, or if that is a |
| * WC root then on @a local_abspath itself. |
| * |
| * If @a local_abspath is a file, all its info will be removed from the |
| * administrative area. If @a local_abspath is a directory, then the |
| * administrative area will be deleted, along with *all* the administrative |
| * areas anywhere in the tree below @a adm_access. |
| * |
| * Normally, only administrative data is removed. However, if |
| * @a destroy_wf is TRUE, then all working file(s) and dirs are deleted |
| * from disk as well. When called with @a destroy_wf, any locally |
| * modified files will *not* be deleted, and the special error |
| * #SVN_ERR_WC_LEFT_LOCAL_MOD might be returned. (Callers only need to |
| * check for this special return value if @a destroy_wf is TRUE.) |
| * |
| * If @a instant_error is TRUE, then return |
| * #SVN_ERR_WC_LEFT_LOCAL_MOD the instant a locally modified file is |
| * encountered. Otherwise, leave locally modified files in place and |
| * return the error only after all the recursion is complete. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton at |
| * various points during the removal. If it returns an error |
| * (typically #SVN_ERR_CANCELLED), return that error immediately. |
| * |
| * WARNING: This routine is exported for careful, measured use by |
| * libsvn_client. Do *not* call this routine unless you really |
| * understand what the heck you're doing. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_remove_from_revision_control2(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_boolean_t destroy_wf, |
| svn_boolean_t instant_error, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_remove_from_revision_control2() but with a name |
| * and access baton. |
| * |
| * WARNING: This routine was exported for careful, measured use by |
| * libsvn_client. Do *not* call this routine unless you really |
| * understand what the heck you're doing. |
| * |
| * @deprecated Provided for compatibility with the 1.6 API |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_remove_from_revision_control(svn_wc_adm_access_t *adm_access, |
| const char *name, |
| svn_boolean_t destroy_wf, |
| svn_boolean_t instant_error, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Assuming @a local_abspath is under version control or a tree conflict |
| * victim and in a state of conflict, then take @a local_abspath *out* |
| * of this state. If @a resolve_text is TRUE then any text conflict is |
| * resolved, if @a resolve_tree is TRUE then any tree conflicts are |
| * resolved. If @a resolve_prop is set to "" all property conflicts are |
| * resolved, if it is set to any other string value, conflicts on that |
| * specific property are resolved and when resolve_prop is NULL, no |
| * property conflicts are resolved. |
| * |
| * If @a depth is #svn_depth_empty, act only on @a local_abspath; if |
| * #svn_depth_files, resolve @a local_abspath and its conflicted file |
| * children (if any); if #svn_depth_immediates, resolve @a local_abspath |
| * and all its immediate conflicted children (both files and directories, |
| * if any); if #svn_depth_infinity, resolve @a local_abspath and every |
| * conflicted file or directory anywhere beneath it. |
| * |
| * If @a conflict_choice is #svn_wc_conflict_choose_base, resolve the |
| * conflict with the old file contents; if |
| * #svn_wc_conflict_choose_mine_full, use the original working contents; |
| * if #svn_wc_conflict_choose_theirs_full, the new contents; and if |
| * #svn_wc_conflict_choose_merged, don't change the contents at all, |
| * just remove the conflict status, which is the pre-1.5 behavior. |
| * |
| * #svn_wc_conflict_choose_theirs_conflict and |
| * #svn_wc_conflict_choose_mine_conflict are not legal for binary |
| * files or properties. |
| * |
| * @a wc_ctx is a working copy context, with a write lock, for @a |
| * local_abspath. |
| * |
| * Needless to say, this function doesn't touch conflict markers or |
| * anything of that sort -- only a human can semantically resolve a |
| * conflict. Instead, this function simply marks a file as "having |
| * been resolved", clearing the way for a commit. |
| * |
| * The implementation details are opaque, as our "conflicted" criteria |
| * might change over time. (At the moment, this routine removes the |
| * three fulltext 'backup' files and any .prej file created in a conflict, |
| * and modifies @a local_abspath's entry.) |
| * |
| * If @a local_abspath is not under version control and not a tree |
| * conflict, return #SVN_ERR_ENTRY_NOT_FOUND. If @a path isn't in a |
| * state of conflict to begin with, do nothing, and return #SVN_NO_ERROR. |
| * |
| * If @c local_abspath was successfully taken out of a state of conflict, |
| * report this information to @c notify_func (if non-@c NULL.) If only |
| * text, only property, or only tree conflict resolution was requested, |
| * and it was successful, then success gets reported. |
| * |
| * Temporary allocations will be performed in @a scratch_pool. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.9 API. |
| * Use svn_client_conflict_text_resolve(), svn_client_conflict_prop_resolve(), |
| * and svn_client_conflict_tree_resolve() instead. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_resolved_conflict5(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_depth_t depth, |
| svn_boolean_t resolve_text, |
| const char *resolve_prop, |
| svn_boolean_t resolve_tree, |
| svn_wc_conflict_choice_t conflict_choice, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_resolved_conflict5, but takes an absolute path |
| * and an access baton. This version doesn't support resolving a specific |
| * property.conflict. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_resolved_conflict4(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t resolve_text, |
| svn_boolean_t resolve_props, |
| svn_boolean_t resolve_tree, |
| svn_depth_t depth, |
| svn_wc_conflict_choice_t conflict_choice, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Similar to svn_wc_resolved_conflict4(), but without tree-conflict |
| * resolution support. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backward compatibility with the 1.5 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_resolved_conflict3(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t resolve_text, |
| svn_boolean_t resolve_props, |
| svn_depth_t depth, |
| svn_wc_conflict_choice_t conflict_choice, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Similar to svn_wc_resolved_conflict3(), but without automatic conflict |
| * resolution support, and with @a depth set according to @a recurse: |
| * if @a recurse is TRUE, @a depth is #svn_depth_infinity, else it is |
| * #svn_depth_files. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_resolved_conflict2(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t resolve_text, |
| svn_boolean_t resolve_props, |
| svn_boolean_t recurse, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_resolved_conflict2(), but takes an |
| * svn_wc_notify_func_t and doesn't have cancellation support. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_resolved_conflict(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t resolve_text, |
| svn_boolean_t resolve_props, |
| svn_boolean_t recurse, |
| svn_wc_notify_func_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| |
| /* Commits. */ |
| |
| |
| /** |
| * Storage type for queued post-commit data. |
| * |
| * @since New in 1.5. |
| */ |
| typedef struct svn_wc_committed_queue_t svn_wc_committed_queue_t; |
| |
| |
| /** |
| * Create a queue for use with svn_wc_queue_committed() and |
| * svn_wc_process_committed_queue(). |
| * |
| * The returned queue and all further allocations required for queuing |
| * new items will also be done from @a pool. |
| * |
| * @since New in 1.5. |
| */ |
| svn_wc_committed_queue_t * |
| svn_wc_committed_queue_create(apr_pool_t *pool); |
| |
| |
| /** |
| * Queue committed items to be processed later by |
| * svn_wc_process_committed_queue2(). |
| * |
| * Record in @a queue that @a local_abspath will need to be bumped |
| * after a commit succeeds. |
| * |
| * If non-NULL, @a wcprop_changes is an array of <tt>svn_prop_t *</tt> |
| * changes to wc properties; if an #svn_prop_t->value is NULL, then |
| * that property is deleted. |
| * ### [JAF] No, a prop whose value is NULL is ignored, not deleted. This |
| * ### seems to be not a set of changes but rather the new complete set of |
| * ### props. And it's renamed to 'new_dav_cache' inside; why? |
| * |
| * If @a is_committed is @c TRUE, the node will be processed as committed. This |
| * turns the node and its implied descendants as the new unmodified state at |
| * the new specified revision. Unless @a recurse is TRUE, changes on |
| * descendants are not committed as changes directly. In this case they should |
| * be queued as their own changes. |
| * |
| * If @a remove_lock is @c TRUE, any entryprops related to a repository |
| * lock will be removed. |
| * |
| * If @a remove_changelist is @c TRUE, any association with a |
| * changelist will be removed. |
| * |
| * |
| * If @a sha1_checksum is non-NULL, use it to identify the node's pristine |
| * text. |
| * |
| * If @a recurse is TRUE and @a local_abspath is a directory, then bump every |
| * versioned object at or under @a local_abspath. This is usually done for |
| * copied trees. |
| * |
| * ### In the present implementation, if a recursive directory item is in |
| * the queue, then any children (at any depth) of that directory that |
| * are also in the queue as separate items will get: |
| * 'wcprop_changes' = NULL; |
| * 'remove_lock' = FALSE; |
| * 'remove_changelist' from the recursive parent item; |
| * and any children (at any depth) of that directory that are NOT in |
| * the queue as separate items will get: |
| * 'wcprop_changes' = NULL; |
| * 'remove_lock' = FALSE; |
| * 'remove_changelist' from the recursive parent item; |
| * |
| * @note the @a recurse parameter should be used with extreme care since |
| * it will bump ALL nodes under the directory, regardless of their |
| * actual inclusion in the new revision. |
| * |
| * All pointer data passed to this function (@a local_abspath, |
| * @a wcprop_changes and the checksums) should remain valid until the |
| * queue has been processed by svn_wc_process_committed_queue2(). |
| * |
| * Temporary allocations will be performed in @a scratch_pool, and persistent |
| * allocations will use the same pool as @a queue used when it was created. |
| * |
| * @since New in 1.9. |
| */ |
| svn_error_t * |
| svn_wc_queue_committed4(svn_wc_committed_queue_t *queue, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_boolean_t recurse, |
| svn_boolean_t is_committed, |
| const apr_array_header_t *wcprop_changes, |
| svn_boolean_t remove_lock, |
| svn_boolean_t remove_changelist, |
| const svn_checksum_t *sha1_checksum, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_queue_committed4, but with is_committed always |
| * TRUE. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backwards compatibility with the 1.8 API. |
| */ |
| svn_error_t * |
| svn_wc_queue_committed3(svn_wc_committed_queue_t *queue, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_boolean_t recurse, |
| const apr_array_header_t *wcprop_changes, |
| svn_boolean_t remove_lock, |
| svn_boolean_t remove_changelist, |
| const svn_checksum_t *sha1_checksum, |
| apr_pool_t *scratch_pool); |
| |
| /** Same as svn_wc_queue_committed3() except @a path doesn't have to be an |
| * abspath and @a adm_access is unused and a SHA-1 checksum cannot be |
| * specified. |
| * |
| * @since New in 1.6. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_queue_committed2(svn_wc_committed_queue_t *queue, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t recurse, |
| const apr_array_header_t *wcprop_changes, |
| svn_boolean_t remove_lock, |
| svn_boolean_t remove_changelist, |
| const svn_checksum_t *md5_checksum, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Same as svn_wc_queue_committed2() but the @a queue parameter has an |
| * extra indirection and @a digest is supplied instead of a checksum type. |
| * |
| * @note despite the extra indirection, this function does NOT allocate |
| * the queue for you. svn_wc_committed_queue_create() must be called. |
| * |
| * @since New in 1.5 |
| * |
| * @deprecated Provided for backwards compatibility with 1.5 |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_queue_committed(svn_wc_committed_queue_t **queue, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t recurse, |
| const apr_array_header_t *wcprop_changes, |
| svn_boolean_t remove_lock, |
| svn_boolean_t remove_changelist, |
| const unsigned char *digest, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Bump all items in @a queue to @a new_revnum after a commit succeeds. |
| * @a rev_date and @a rev_author are the (server-side) date and author |
| * of the new revision; one or both may be @c NULL. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine |
| * if the client wants to cancel the operation. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_process_committed_queue2(svn_wc_committed_queue_t *queue, |
| svn_wc_context_t *wc_ctx, |
| svn_revnum_t new_revnum, |
| const char *rev_date, |
| const char *rev_author, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** @see svn_wc_process_committed_queue2() |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backwards compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_process_committed_queue(svn_wc_committed_queue_t *queue, |
| svn_wc_adm_access_t *adm_access, |
| svn_revnum_t new_revnum, |
| const char *rev_date, |
| const char *rev_author, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * @note this function has improper expectations around the operation and |
| * execution of other parts of the Subversion WC library. The resulting |
| * coupling makes this interface near-impossible to support. Documentation |
| * has been removed, as a result. |
| * |
| * @deprecated Use the svn_wc_committed_queue_* functions instead. Provided |
| * for backwards compatibility with the 1.5 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_process_committed4(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t recurse, |
| svn_revnum_t new_revnum, |
| const char *rev_date, |
| const char *rev_author, |
| const apr_array_header_t *wcprop_changes, |
| svn_boolean_t remove_lock, |
| svn_boolean_t remove_changelist, |
| const unsigned char *digest, |
| apr_pool_t *pool); |
| |
| /** @see svn_wc_process_committed4() |
| * |
| * @deprecated Use the svn_wc_committed_queue_* functions instead. Provided |
| * for backwards compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_process_committed3(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t recurse, |
| svn_revnum_t new_revnum, |
| const char *rev_date, |
| const char *rev_author, |
| const apr_array_header_t *wcprop_changes, |
| svn_boolean_t remove_lock, |
| const unsigned char *digest, |
| apr_pool_t *pool); |
| |
| /** @see svn_wc_process_committed4() |
| * |
| * @deprecated Use the svn_wc_committed_queue_* functions instead. Provided |
| * for backwards compatibility with the 1.3 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_process_committed2(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t recurse, |
| svn_revnum_t new_revnum, |
| const char *rev_date, |
| const char *rev_author, |
| const apr_array_header_t *wcprop_changes, |
| svn_boolean_t remove_lock, |
| apr_pool_t *pool); |
| |
| /** @see svn_wc_process_committed4() |
| * |
| * @deprecated Use the svn_wc_committed_queue_* functions instead. Provided |
| * for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_process_committed(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t recurse, |
| svn_revnum_t new_revnum, |
| const char *rev_date, |
| const char *rev_author, |
| const apr_array_header_t *wcprop_changes, |
| apr_pool_t *pool); |
| |
| |
| |
| |
| |
| /** |
| * Do a depth-first crawl in a working copy, beginning at @a local_abspath, |
| * using @a wc_ctx for accessing the working copy. |
| * |
| * Communicate the `state' of the working copy's revisions and depths |
| * to @a reporter/@a report_baton. Obviously, if @a local_abspath is a |
| * file instead of a directory, this depth-first crawl will be a short one. |
| * |
| * No locks or logs are created, nor are any animals harmed in the |
| * process unless @a restore_files is TRUE. No cleanup is necessary. |
| * |
| * After all revisions are reported, @a reporter->finish_report() is |
| * called, which immediately causes the RA layer to update the working |
| * copy. Thus the return value may very well reflect the result of |
| * the update! |
| * |
| * If @a depth is #svn_depth_empty, then report state only for |
| * @a path itself. If #svn_depth_files, do the same and include |
| * immediate file children of @a path. If #svn_depth_immediates, |
| * then behave as if for #svn_depth_files but also report the |
| * property states of immediate subdirectories. If @a depth is |
| * #svn_depth_infinity, then report state fully recursively. All |
| * descents are only as deep as @a path's own depth permits, of |
| * course. If @a depth is #svn_depth_unknown, then just use |
| * #svn_depth_infinity, which in practice means depth of @a path. |
| * |
| * Iff @a honor_depth_exclude is TRUE, the crawler will report paths |
| * whose ambient depth is #svn_depth_exclude as being excluded, and |
| * thus prevent the server from pushing update data for those paths; |
| * therefore, don't set this flag if you wish to pull in excluded paths. |
| * Note that #svn_depth_exclude on the target @a path is never |
| * honored, even if @a honor_depth_exclude is TRUE, because we need to |
| * be able to explicitly pull in a target. For example, if this is |
| * the working copy... |
| * |
| * svn co greek_tree_repos wc_dir |
| * svn up --set-depth exclude wc_dir/A/B/E # now A/B/E is excluded |
| * |
| * ...then 'svn up wc_dir/A/B' would report E as excluded (assuming |
| * @a honor_depth_exclude is TRUE), but 'svn up wc_dir/A/B/E' would |
| * not, because the latter is trying to explicitly pull in E. In |
| * general, we never report the update target as excluded. |
| * |
| * Iff @a depth_compatibility_trick is TRUE, then set the @c start_empty |
| * flag on @a reporter->set_path() and @a reporter->link_path() calls |
| * as necessary to trick a pre-1.5 (i.e., depth-unaware) server into |
| * sending back all the items the client might need to upgrade a |
| * working copy from a shallower depth to a deeper one. |
| * |
| * If @a restore_files is TRUE, then unexpectedly missing working files |
| * will be restored from the administrative directory's cache. For each |
| * file restored, the @a notify_func function will be called with the |
| * @a notify_baton and the path of the restored file. @a notify_func may |
| * be @c NULL if this notification is not required. If @a |
| * use_commit_times is TRUE, then set restored files' timestamps to |
| * their last-commit-times. For working copies that do not store local |
| * pristine contents for all files, return @c SVN_ERR_WC_PRISTINE_DEHYDRATED |
| * on an attempt to restore a file whose pristine contents is not present |
| * locally. |
| * |
| * @note This is a relatively low-level function operating directly on a |
| * working copy, so a caller is expected to be able to handle working copies |
| * that do not store local copies of all pristine contents. This can be |
| * achieved by synchronizing the text-base state before and optionally |
| * after the function call. @see svn_wc_textbase_sync(). |
| * |
| * @since New in 1.15. |
| */ |
| svn_error_t * |
| svn_wc_crawl_revisions6(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| const svn_ra_reporter3_t *reporter, |
| void *report_baton, |
| svn_boolean_t restore_files, |
| svn_depth_t depth, |
| svn_boolean_t honor_depth_exclude, |
| svn_boolean_t depth_compatibility_trick, |
| svn_boolean_t use_commit_times, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_crawl_revisions6, but if @a restore_files is @c TRUE, |
| * this function can only be used for working copies that store local |
| * copies of all pristine contents. |
| * |
| * If @a restore_files is @c TRUE and a working copy doesn't store local copies |
| * of all pristine contents, an #SVN_ERR_WC_DEPRECATED_API_STORE_PRISTINE |
| * error will be returned. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_crawl_revisions5(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| const svn_ra_reporter3_t *reporter, |
| void *report_baton, |
| svn_boolean_t restore_files, |
| svn_depth_t depth, |
| svn_boolean_t honor_depth_exclude, |
| svn_boolean_t depth_compatibility_trick, |
| svn_boolean_t use_commit_times, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_crawl_revisions5, but with a relative path and |
| * access baton instead of an absolute path and wc_ctx. |
| * |
| * Passes NULL for @a cancel_func and @a cancel_baton. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_crawl_revisions4(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| const svn_ra_reporter3_t *reporter, |
| void *report_baton, |
| svn_boolean_t restore_files, |
| svn_depth_t depth, |
| svn_boolean_t honor_depth_exclude, |
| svn_boolean_t depth_compatibility_trick, |
| svn_boolean_t use_commit_times, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| svn_wc_traversal_info_t *traversal_info, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Similar to svn_wc_crawl_revisions4, but with @a honor_depth_exclude always |
| * set to false. |
| * |
| * @deprecated Provided for compatibility with the 1.5 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_crawl_revisions3(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| const svn_ra_reporter3_t *reporter, |
| void *report_baton, |
| svn_boolean_t restore_files, |
| svn_depth_t depth, |
| svn_boolean_t depth_compatibility_trick, |
| svn_boolean_t use_commit_times, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| svn_wc_traversal_info_t *traversal_info, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_crawl_revisions3, but taking svn_ra_reporter2_t |
| * instead of svn_ra_reporter3_t, and therefore only able to report |
| * #svn_depth_infinity for depths; and taking @a recurse instead of @a |
| * depth; and with @a depth_compatibility_trick always false. |
| * |
| * @deprecated Provided for compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_crawl_revisions2(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| const svn_ra_reporter2_t *reporter, |
| void *report_baton, |
| svn_boolean_t restore_files, |
| svn_boolean_t recurse, |
| svn_boolean_t use_commit_times, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| svn_wc_traversal_info_t *traversal_info, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_crawl_revisions2(), but takes an #svn_wc_notify_func_t |
| * and a #svn_ra_reporter_t instead. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_crawl_revisions(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| const svn_ra_reporter_t *reporter, |
| void *report_baton, |
| svn_boolean_t restore_files, |
| svn_boolean_t recurse, |
| svn_boolean_t use_commit_times, |
| svn_wc_notify_func_t notify_func, |
| void *notify_baton, |
| svn_wc_traversal_info_t *traversal_info, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * @defgroup svn_wc_roots Working copy roots |
| * @{ |
| */ |
| |
| /** If @a is_wcroot is not @c NULL, set @a *is_wcroot to @c TRUE if @a |
| * local_abspath is the root of the working copy, otherwise to @c FALSE. |
| * |
| * If @a is_switched is not @c NULL, set @a *is_switched to @c TRUE if @a |
| * local_abspath is not the root of the working copy, and switched against its |
| * parent. |
| * |
| * If @a kind is not @c NULL, set @a *kind to the node kind of @a |
| * local_abspath. |
| * |
| * Use @a scratch_pool for any temporary allocations. |
| * |
| * @since New in 1.8. |
| */ |
| svn_error_t * |
| svn_wc_check_root(svn_boolean_t *is_wcroot, |
| svn_boolean_t *is_switched, |
| svn_node_kind_t *kind, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *scratch_pool); |
| |
| /** Set @a *wc_root to @c TRUE if @a local_abspath represents a "working copy |
| * root", @c FALSE otherwise. Here, @a local_abspath is a "working copy root" |
| * if its parent directory is not a WC or if it is switched. Also, a deleted |
| * tree-conflict victim is considered a "working copy root" because it has no |
| * URL. |
| * |
| * If @a local_abspath is not found, return the error #SVN_ERR_ENTRY_NOT_FOUND. |
| * |
| * Use @a scratch_pool for any temporary allocations. |
| * |
| * @note For legacy reasons only a directory can be a wc-root. However, this |
| * function will also set wc_root to @c TRUE for a switched file. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.7 API. Consider |
| * using svn_wc_check_root() instead. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_is_wc_root2(svn_boolean_t *wc_root, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** |
| * Similar to svn_wc_is_wc_root2(), but with an access baton and relative |
| * path. |
| * |
| * @note If @a path is '', this function will always return @c TRUE. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_is_wc_root(svn_boolean_t *wc_root, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /* Updates. */ |
| |
| /** Conditionally split @a path into an @a anchor and @a target for the |
| * purpose of updating and committing. |
| * |
| * @a anchor is the directory at which the update or commit editor |
| * should be rooted. |
| * |
| * @a target is the actual subject (relative to the @a anchor) of the |
| * update/commit, or "" if the @a anchor itself is the subject. |
| * |
| * Allocate @a anchor and @a target in @a result_pool; @a scratch_pool |
| * is used for temporary allocations. |
| * |
| * @note Even though this API uses a #svn_wc_context_t, it accepts a |
| * (possibly) relative path and returns a (possibly) relative path in |
| * @a *anchor. The reason being that the outputs are generally used to |
| * open access batons, and such opening currently requires relative paths. |
| * In the long-run, I expect this API to be removed from 1.7, due to the |
| * remove of access batons, but for the time being, the #svn_wc_context_t |
| * parameter allows us to avoid opening a duplicate database, just for this |
| * function. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_get_actual_target2(const char **anchor, |
| const char **target, |
| svn_wc_context_t *wc_ctx, |
| const char *path, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Similar to svn_wc_get_actual_target2(), but without the wc context, and |
| * with a absolute path. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_actual_target(const char *path, |
| const char **anchor, |
| const char **target, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * @defgroup svn_wc_update_switch Update and switch (update-like functionality) |
| * @{ |
| */ |
| |
| /** |
| * A simple callback type to wrap svn_ra_get_file(); see that |
| * docstring for more information. |
| * |
| * This technique allows libsvn_client to 'wrap' svn_ra_get_file() and |
| * pass it down into libsvn_wc functions, thus allowing the WC layer |
| * to legally call the RA function via (blind) callback. |
| * |
| * @since New in 1.5 |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| typedef svn_error_t *(*svn_wc_get_file_t)(void *baton, |
| const char *path, |
| svn_revnum_t revision, |
| svn_stream_t *stream, |
| svn_revnum_t *fetched_rev, |
| apr_hash_t **props, |
| apr_pool_t *pool); |
| |
| /** |
| * A simple callback type to wrap svn_ra_get_dir2() for avoiding issue #3569, |
| * where a directory is updated to a revision without some of its children |
| * recorded in the working copy. A future update won't bring these files in |
| * because the repository assumes they are already there. |
| * |
| * We really only need the names of the dirents for a not-present marking, |
| * but we also store the node-kind if we receive one. |
| * |
| * @a *dirents should be set to a hash mapping <tt>const char *</tt> child |
| * names, to <tt>const svn_dirent_t *</tt> instances. |
| * |
| * @since New in 1.7. |
| */ |
| typedef svn_error_t *(*svn_wc_dirents_func_t)(void *baton, |
| apr_hash_t **dirents, |
| const char *repos_root_url, |
| const char *repos_relpath, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** |
| * DEPRECATED -- please use APIs from svn_client.h |
| * |
| * --- |
| * |
| * Set @a *editor and @a *edit_baton to an editor and baton for updating a |
| * working copy. |
| * |
| * @a anchor_abspath is a local working copy directory, with a fully recursive |
| * write lock in @a wc_ctx, which will be used as the root of our editor. |
| * |
| * @a target_basename is the entry in @a anchor_abspath that will actually be |
| * updated, or the empty string if all of @a anchor_abspath should be updated. |
| * |
| * The editor invokes @a notify_func with @a notify_baton as the update |
| * progresses, if @a notify_func is non-NULL. |
| * |
| * If @a cancel_func is non-NULL, the editor will invoke @a cancel_func with |
| * @a cancel_baton as the update progresses to see if it should continue. |
| * |
| * If @a conflict_func is non-NULL, then invoke it with @a |
| * conflict_baton whenever a conflict is encountered, giving the |
| * callback a chance to resolve the conflict before the editor takes |
| * more drastic measures (such as marking a file conflicted, or |
| * bailing out of the update). |
| * |
| * If @a external_func is non-NULL, then invoke it with @a external_baton |
| * whenever external changes are encountered, giving the callback a chance |
| * to store the external information for processing. |
| * |
| * If @a diff3_cmd is non-NULL, then use it as the diff3 command for |
| * any merging; otherwise, use the built-in merge code. |
| * |
| * @a preserved_exts is an array of filename patterns which, when |
| * matched against the extensions of versioned files, determine for |
| * which such files any related generated conflict files will preserve |
| * the original file's extension as their own. If a file's extension |
| * does not match any of the patterns in @a preserved_exts (which is |
| * certainly the case if @a preserved_exts is @c NULL or empty), |
| * generated conflict files will carry Subversion's custom extensions. |
| * |
| * @a target_revision is a pointer to a revision location which, after |
| * successful completion of the drive of this editor, will be |
| * populated with the revision to which the working copy was updated. |
| * |
| * If @a use_commit_times is TRUE, then all edited/added files will |
| * have their working timestamp set to the last-committed-time. If |
| * FALSE, the working files will be touched with the 'now' time. |
| * |
| * If @a allow_unver_obstructions is TRUE, then allow unversioned |
| * obstructions when adding a path. |
| * |
| * If @a adds_as_modification is TRUE, a local addition at the same path |
| * as an incoming addition of the same node kind results in a normal node |
| * with a possible local modification, instead of a tree conflict. |
| * |
| * If @a depth is #svn_depth_infinity, update fully recursively. |
| * Else if it is #svn_depth_immediates, update the uppermost |
| * directory, its file entries, and the presence or absence of |
| * subdirectories (but do not descend into the subdirectories). |
| * Else if it is #svn_depth_files, update the uppermost directory |
| * and its immediate file entries, but not subdirectories. |
| * Else if it is #svn_depth_empty, update exactly the uppermost |
| * target, and don't touch its entries. |
| * |
| * If @a depth_is_sticky is set and @a depth is not |
| * #svn_depth_unknown, then in addition to updating PATHS, also set |
| * their sticky ambient depth value to @a depth. |
| * |
| * If @a server_performs_filtering is TRUE, assume that the server handles |
| * the ambient depth filtering, so this doesn't have to be handled in the |
| * editor. |
| * |
| * If @a clean_checkout is TRUE, assume that we are checking out into an |
| * empty directory, and so bypass a number of conflict checks that are |
| * unnecessary in this case. |
| * |
| * If @a fetch_dirents_func is not NULL, the update editor may call this |
| * callback, when asked to perform a depth restricted update. It will do this |
| * before returning the editor to allow using the primary ra session for this. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_update_editor4(const svn_delta_editor_t **editor, |
| void **edit_baton, |
| svn_revnum_t *target_revision, |
| svn_wc_context_t *wc_ctx, |
| const char *anchor_abspath, |
| const char *target_basename, |
| svn_boolean_t use_commit_times, |
| svn_depth_t depth, |
| svn_boolean_t depth_is_sticky, |
| svn_boolean_t allow_unver_obstructions, |
| svn_boolean_t adds_as_modification, |
| svn_boolean_t server_performs_filtering, |
| svn_boolean_t clean_checkout, |
| const char *diff3_cmd, |
| const apr_array_header_t *preserved_exts, |
| svn_wc_dirents_func_t fetch_dirents_func, |
| void *fetch_dirents_baton, |
| svn_wc_conflict_resolver_func2_t conflict_func, |
| void *conflict_baton, |
| svn_wc_external_update_t external_func, |
| void *external_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_get_update_editor4, but uses access batons and relative |
| * path instead of a working copy context-abspath pair and |
| * svn_wc_traversal_info_t instead of an externals callback. Also, |
| * @a fetch_func and @a fetch_baton are ignored. |
| * |
| * If @a ti is non-NULL, record traversal info in @a ti, for use by |
| * post-traversal accessors such as svn_wc_edited_externals(). |
| * |
| * All locks, both those in @a anchor and newly acquired ones, will be |
| * released when the editor driver calls @c close_edit. |
| * |
| * Always sets @a adds_as_modification to TRUE, @a server_performs_filtering |
| * and @a clean_checkout to FALSE. |
| * |
| * Uses a svn_wc_conflict_resolver_func_t conflict resolver instead of a |
| * svn_wc_conflict_resolver_func2_t. |
| * |
| * This function assumes that @a diff3_cmd is path encoded. Later versions |
| * assume utf-8. |
| * |
| * Always passes a null dirent function. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_update_editor3(svn_revnum_t *target_revision, |
| svn_wc_adm_access_t *anchor, |
| const char *target, |
| svn_boolean_t use_commit_times, |
| svn_depth_t depth, |
| svn_boolean_t depth_is_sticky, |
| svn_boolean_t allow_unver_obstructions, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_conflict_resolver_func_t conflict_func, |
| void *conflict_baton, |
| svn_wc_get_file_t fetch_func, |
| void *fetch_baton, |
| const char *diff3_cmd, |
| const apr_array_header_t *preserved_exts, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| svn_wc_traversal_info_t *ti, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Similar to svn_wc_get_update_editor3() but with the @a |
| * allow_unver_obstructions parameter always set to FALSE, @a |
| * conflict_func and baton set to NULL, @a fetch_func and baton set to |
| * NULL, @a preserved_exts set to NULL, @a depth_is_sticky set to |
| * FALSE, and @a depth set according to @a recurse: if @a recurse is |
| * TRUE, pass #svn_depth_infinity, if FALSE, pass #svn_depth_files. |
| * |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_update_editor2(svn_revnum_t *target_revision, |
| svn_wc_adm_access_t *anchor, |
| const char *target, |
| svn_boolean_t use_commit_times, |
| svn_boolean_t recurse, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| const char *diff3_cmd, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| svn_wc_traversal_info_t *ti, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_get_update_editor2(), but takes an svn_wc_notify_func_t |
| * instead. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_update_editor(svn_revnum_t *target_revision, |
| svn_wc_adm_access_t *anchor, |
| const char *target, |
| svn_boolean_t use_commit_times, |
| svn_boolean_t recurse, |
| svn_wc_notify_func_t notify_func, |
| void *notify_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| const char *diff3_cmd, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| svn_wc_traversal_info_t *ti, |
| apr_pool_t *pool); |
| |
| /** |
| * DEPRECATED -- please use APIs from svn_client.h |
| * |
| * --- |
| * |
| * A variant of svn_wc_get_update_editor4(). |
| * |
| * Set @a *editor and @a *edit_baton to an editor and baton for "switching" |
| * a working copy to a new @a switch_url. (Right now, this URL must be |
| * within the same repository that the working copy already comes |
| * from.) @a switch_url must not be @c NULL. |
| * |
| * All other parameters behave as for svn_wc_get_update_editor4(). |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_switch_editor4(const svn_delta_editor_t **editor, |
| void **edit_baton, |
| svn_revnum_t *target_revision, |
| svn_wc_context_t *wc_ctx, |
| const char *anchor_abspath, |
| const char *target_basename, |
| const char *switch_url, |
| svn_boolean_t use_commit_times, |
| svn_depth_t depth, |
| svn_boolean_t depth_is_sticky, |
| svn_boolean_t allow_unver_obstructions, |
| svn_boolean_t server_performs_filtering, |
| const char *diff3_cmd, |
| const apr_array_header_t *preserved_exts, |
| svn_wc_dirents_func_t fetch_dirents_func, |
| void *fetch_dirents_baton, |
| svn_wc_conflict_resolver_func2_t conflict_func, |
| void *conflict_baton, |
| svn_wc_external_update_t external_func, |
| void *external_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_get_switch_editor4, but uses access batons and relative |
| * path instead of a working copy context and svn_wc_traversal_info_t instead |
| * of an externals callback. |
| * |
| * If @a ti is non-NULL, record traversal info in @a ti, for use by |
| * post-traversal accessors such as svn_wc_edited_externals(). |
| * |
| * All locks, both those in @a anchor and newly acquired ones, will be |
| * released when the editor driver calls @c close_edit. |
| * |
| * Always sets @a server_performs_filtering to FALSE. |
| * |
| * Uses a svn_wc_conflict_resolver_func_t conflict resolver instead of a |
| * svn_wc_conflict_resolver_func2_t. |
| * |
| * This function assumes that @a diff3_cmd is path encoded. Later versions |
| * assume utf-8. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_switch_editor3(svn_revnum_t *target_revision, |
| svn_wc_adm_access_t *anchor, |
| const char *target, |
| const char *switch_url, |
| svn_boolean_t use_commit_times, |
| svn_depth_t depth, |
| svn_boolean_t depth_is_sticky, |
| svn_boolean_t allow_unver_obstructions, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_conflict_resolver_func_t conflict_func, |
| void *conflict_baton, |
| const char *diff3_cmd, |
| const apr_array_header_t *preserved_exts, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| svn_wc_traversal_info_t *ti, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_get_switch_editor3() but with the |
| * @a allow_unver_obstructions parameter always set to FALSE, |
| * @a preserved_exts set to NULL, @a conflict_func and baton set to NULL, |
| * @a depth_is_sticky set to FALSE, and @a depth set according to @a |
| * recurse: if @a recurse is TRUE, pass #svn_depth_infinity, if |
| * FALSE, pass #svn_depth_files. |
| * |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_switch_editor2(svn_revnum_t *target_revision, |
| svn_wc_adm_access_t *anchor, |
| const char *target, |
| const char *switch_url, |
| svn_boolean_t use_commit_times, |
| svn_boolean_t recurse, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| const char *diff3_cmd, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| svn_wc_traversal_info_t *ti, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_get_switch_editor2(), but takes an |
| * #svn_wc_notify_func_t instead. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_switch_editor(svn_revnum_t *target_revision, |
| svn_wc_adm_access_t *anchor, |
| const char *target, |
| const char *switch_url, |
| svn_boolean_t use_commit_times, |
| svn_boolean_t recurse, |
| svn_wc_notify_func_t notify_func, |
| void *notify_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| const char *diff3_cmd, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| svn_wc_traversal_info_t *ti, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup svn_wc_properties Properties |
| * @{ |
| */ |
| |
| /** Set @a *props to a hash table mapping <tt>char *</tt> names onto |
| * <tt>svn_string_t *</tt> values for all the regular properties of |
| * @a local_abspath. Allocate the table, names, and values in |
| * @a result_pool. If the node has no properties, then an empty hash |
| * is returned. Use @a wc_ctx to access the working copy, and @a |
| * scratch_pool for temporary allocations. |
| * |
| * If the node does not exist, #SVN_ERR_WC_PATH_NOT_FOUND is returned. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_prop_list2(apr_hash_t **props, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_prop_list2() but with a #svn_wc_adm_access_t / |
| * relative path parameter pair. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_prop_list(apr_hash_t **props, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| |
| /** Return the set of "pristine" properties for @a local_abspath. |
| * |
| * There are node states where properties do not make sense. For these |
| * cases, NULL will be returned in @a *props. Otherwise, a hash table |
| * will always be returned (but may be empty, indicating no properties). |
| * |
| * If the node is locally-added, then @a *props will be set to NULL since |
| * pristine properties are undefined. Note: if this addition is replacing a |
| * previously-deleted node, then the replaced node's properties are not |
| * available until the addition is reverted. |
| * |
| * If the node has been copied (from another node in the repository), then |
| * the pristine properties will correspond to those original properties. |
| * |
| * If the node is locally-deleted, these properties will correspond to |
| * the BASE node's properties, as checked-out from the repository. Note: if |
| * this deletion is a child of a copy, then the pristine properties will |
| * correspond to that copy's properties, not any potential BASE node. The |
| * BASE node's properties will not be accessible until the copy is reverted. |
| * |
| * Nodes that are incomplete, excluded, absent, or not present at the |
| * node's revision will return NULL in @a props. |
| * |
| * If the node is not versioned, SVN_ERR_WC_PATH_NOT_FOUND will be returned. |
| * |
| * @a props will be allocated in @a result_pool, and all temporary |
| * allocations will be performed in @a scratch_pool. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_get_pristine_props(apr_hash_t **props, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Set @a *value to the value of property @a name for @a local_abspath, |
| * allocating @a *value in @a result_pool. If no such prop, set @a *value |
| * to @c NULL. @a name may be a regular or wc property; if it is an |
| * entry property, return the error #SVN_ERR_BAD_PROP_KIND. @a wc_ctx |
| * is used to access the working copy. |
| * |
| * If @a local_abspath is not a versioned path, return |
| * #SVN_ERR_WC_PATH_NOT_FOUND |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_prop_get2(const svn_string_t **value, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| const char *name, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_prop_get2(), but with a #svn_wc_adm_access_t / |
| * relative path parameter pair. |
| * |
| * When @a path is not versioned, set @a *value to NULL. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_prop_get(const svn_string_t **value, |
| const char *name, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| /** |
| * Set property @a name to @a value for @a local_abspath, or if @a value is |
| * NULL, remove property @a name from @a local_abspath. Use @a wc_ctx to |
| * access @a local_abspath. |
| * |
| * @a name may be a regular property or a "wc property". If @a name is |
| * an "entry property", return the error #SVN_ERR_BAD_PROP_KIND (even if |
| * @a skip_checks is TRUE). |
| * |
| * If @a name is a "wc property", then just update the WC DAV cache for |
| * @a local_abspath with @a name and @a value. In this case, @a depth |
| * must be #svn_depth_empty. |
| * |
| * The rest of this description applies when @a name is a regular property. |
| * |
| * If @a name is a name in the reserved "svn:" name space, and @a value is |
| * non-null, then canonicalize the property value and check the property |
| * name and value as documented for svn_wc_canonicalize_svn_prop(). |
| * @a skip_checks controls the level of checking as documented there. |
| * |
| * Return an error if the canonicalization or the check fails. |
| * The error will be either #SVN_ERR_ILLEGAL_TARGET (if the |
| * property is not appropriate for @a path), or |
| * #SVN_ERR_BAD_MIME_TYPE (if @a name is "svn:mime-type", but @a value |
| * is not a valid mime-type). |
| * ### That is not currently right -- several other errors can be raised. |
| * |
| * @a depth follows the usual semantics for depth. |
| * |
| * @a changelist_filter is an array of <tt>const char *</tt> changelist |
| * names, used as a restrictive filter on items whose properties are |
| * set; that is, don't set properties on any item unless it's a member |
| * of one of those changelists. If @a changelist_filter is empty (or |
| * altogether @c NULL), no changelist filtering occurs. |
| * |
| * If @a cancel_func is non-NULL, then it will be invoked (with the |
| * @a cancel_baton value passed) during the processing of the property |
| * set (i.e. when @a depth indicates some amount of recursion). |
| * |
| * For each file or directory operated on, @a notify_func will be called |
| * with its path and the @a notify_baton. @a notify_func may be @c NULL |
| * if you are not interested in this information. |
| * |
| * Use @a scratch_pool for temporary allocation. |
| * |
| * @note If the caller is setting both svn:mime-type and svn:eol-style in |
| * separate calls, and @a skip_checks is false, there is an ordering |
| * dependency between them, as the validity check for svn:eol-style makes |
| * use of the current value of svn:mime-type. |
| * |
| * ### The error code on validity check failure should be specified, and |
| * should be a single code or a very small set of possibilities. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_prop_set4(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| const char *name, |
| const svn_string_t *value, |
| svn_depth_t depth, |
| svn_boolean_t skip_checks, |
| const apr_array_header_t *changelist_filter, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_prop_set4(), but with a #svn_wc_adm_access_t / |
| * relative path parameter pair, no @a depth parameter, no changelist |
| * filtering (for the depth-based property setting), and no cancellation. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for backwards compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_prop_set3(const char *name, |
| const svn_string_t *value, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t skip_checks, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Like svn_wc_prop_set3(), but without the notification callbacks. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backwards compatibility with the 1.5 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_prop_set2(const char *name, |
| const svn_string_t *value, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t skip_checks, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Like svn_wc_prop_set2(), but with @a skip_checks always FALSE. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_prop_set(const char *name, |
| const svn_string_t *value, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| |
| /** Return TRUE iff @a name is a 'normal' property name. 'Normal' is |
| * defined as a user-visible and user-tweakable property that shows up |
| * when you fetch a proplist. |
| * |
| * The function currently parses the namespace like so: |
| * |
| * - 'svn:wc:' ==> a wcprop, stored/accessed separately via different API. |
| * |
| * - 'svn:entry:' ==> an "entry" prop, shunted into the 'entries' file. |
| * |
| * If these patterns aren't found, then the property is assumed to be |
| * Normal. |
| */ |
| svn_boolean_t |
| svn_wc_is_normal_prop(const char *name); |
| |
| |
| |
| /** Return TRUE iff @a name is a 'wc' property name. */ |
| svn_boolean_t |
| svn_wc_is_wc_prop(const char *name); |
| |
| /** Return TRUE iff @a name is a 'entry' property name. */ |
| svn_boolean_t |
| svn_wc_is_entry_prop(const char *name); |
| |
| /** Callback type used by #svn_wc_canonicalize_svn_prop. |
| * |
| * If @a mime_type is non-null, it sets @a *mime_type to the value of |
| * #SVN_PROP_MIME_TYPE for the path passed to |
| * #svn_wc_canonicalize_svn_prop (allocated from @a pool). If @a |
| * stream is non-null, it writes the contents of the file to @a |
| * stream. |
| * |
| * (Currently, this is used if you are attempting to set the |
| * #SVN_PROP_EOL_STYLE property, to make sure that the value matches |
| * the mime type and contents.) |
| * |
| * @since New in 1.5. |
| */ |
| typedef svn_error_t *(*svn_wc_canonicalize_svn_prop_get_file_t)( |
| const svn_string_t **mime_type, |
| svn_stream_t *stream, |
| void *baton, |
| apr_pool_t *pool); |
| |
| |
| /** Canonicalize the value of an svn:* property @a propname with |
| * value @a propval. |
| * |
| * If the property is not appropriate for a node of kind @a kind, or |
| * is otherwise invalid, throw an error. Otherwise, set @a *propval_p |
| * to a canonicalized version of the property value. |
| * |
| * The exact set of canonicalizations and checks may vary across different |
| * versions of this API. Currently: |
| * |
| * - svn:executable |
| * - svn:needs-lock |
| * - svn:special |
| * - set the value to '*' |
| * |
| * - svn:keywords |
| * - strip leading and trailing white space |
| * |
| * - svn:ignore |
| * - svn:global-ignores |
| * - svn:auto-props |
| * - add a final a newline character if missing |
| * |
| * - svn:externals |
| * - add a final a newline character if missing |
| * - check for valid syntax |
| * - check for no duplicate entries |
| * |
| * - svn:mergeinfo |
| * - canonicalize |
| * - check for validity |
| * |
| * Also, unless @a skip_some_checks is TRUE: |
| * |
| * - svn:eol-style |
| * - strip leading and trailing white space |
| * - check value is recognized |
| * - check file content has a self-consistent EOL style |
| * (but not necessarily that it matches @a propval) |
| * |
| * - svn:mime-type |
| * - strip white space |
| * - check for reasonable syntax |
| * |
| * The EOL-style check (if not skipped) requires access to the contents and |
| * MIME type of the target if it is a file. It will call @a prop_getter with |
| * @a getter_baton. The callback must set the MIME type and/or write the |
| * contents of the file to the given stream. If @a skip_some_checks is true, |
| * then @a prop_getter is not used and may be NULL. |
| * |
| * @a path should be the path of the file in question; it is only used |
| * for error messages. |
| * |
| * ### The error code on validity check failure should be specified, and |
| * should be a single code or a very small set of possibilities. |
| * |
| * ### This is not actually related to the WC, but it does need to call |
| * ### svn_wc_parse_externals_description3. |
| * |
| * @since New in 1.5. |
| */ |
| svn_error_t * |
| svn_wc_canonicalize_svn_prop(const svn_string_t **propval_p, |
| const char *propname, |
| const svn_string_t *propval, |
| const char *path, |
| svn_node_kind_t kind, |
| svn_boolean_t skip_some_checks, |
| svn_wc_canonicalize_svn_prop_get_file_t prop_getter, |
| void *getter_baton, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup svn_wc_diffs Diffs |
| * @{ |
| */ |
| |
| /** |
| * DEPRECATED -- please use APIs from svn_client.h |
| * |
| * --- |
| * |
| * Return an @a editor/@a edit_baton for diffing a working copy against the |
| * repository. The editor is allocated in @a result_pool; temporary |
| * calculations are performed in @a scratch_pool. |
| * |
| * This editor supports diffing either the actual files and properties in the |
| * working copy (when @a use_text_base is #FALSE), or the current pristine |
| * information (when @a use_text_base is #TRUE) against the editor driver. |
| * |
| * @a anchor_abspath/@a target represent the base of the hierarchy to be |
| * compared. The diff callback paths will be relative to this path. |
| * |
| * Diffs will be reported as valid relpaths, with @a anchor_abspath being |
| * the root (""). |
| * |
| * @a callbacks/@a callback_baton is the callback table to use. |
| * |
| * If @a depth is #svn_depth_empty, just diff exactly @a target or |
| * @a anchor_path if @a target is empty. If #svn_depth_files then do the same |
| * and for top-level file entries as well (if any). If |
| * #svn_depth_immediates, do the same as #svn_depth_files but also diff |
| * top-level subdirectories at #svn_depth_empty. If #svn_depth_infinity, |
| * then diff fully recursively. |
| * |
| * @a ignore_ancestry determines whether paths that have discontinuous node |
| * ancestry are treated as delete/add or as simple modifications. If |
| * @a ignore_ancestry is @c FALSE, then any discontinuous node ancestry will |
| * result in the diff given as a full delete followed by an add. |
| * |
| * @a show_copies_as_adds determines whether paths added with history will |
| * appear as a diff against their copy source, or whether such paths will |
| * appear as if they were newly added in their entirety. |
| * @a show_copies_as_adds implies not @a ignore_ancestry. |
| * |
| * If @a use_git_diff_format is TRUE, copied paths will be treated as added |
| * if they weren't modified after being copied. This allows the callbacks |
| * to generate appropriate --git diff headers for such files. |
| * @a use_git_diff_format implies @a show_copies_as_adds, and as such implies |
| * not @a ignore_ancestry. |
| * |
| * Normally, the difference from repository->working_copy is shown. |
| * If @a reverse_order is TRUE, then show working_copy->repository diffs. |
| * |
| * If @a cancel_func is non-NULL, it will be used along with @a cancel_baton |
| * to periodically check if the client has canceled the operation. |
| * |
| * @a changelist_filter is an array of <tt>const char *</tt> changelist |
| * names, used as a restrictive filter on items whose differences are |
| * reported; that is, don't generate diffs about any item unless |
| * it's a member of one of those changelists. If @a changelist_filter is |
| * empty (or altogether @c NULL), no changelist filtering occurs. |
| * |
| * If @a server_performs_filtering is TRUE, assume that the server handles |
| * the ambient depth filtering, so this doesn't have to be handled in the |
| * editor. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_diff_editor6(const svn_delta_editor_t **editor, |
| void **edit_baton, |
| svn_wc_context_t *wc_ctx, |
| const char *anchor_abspath, |
| const char *target, |
| svn_depth_t depth, |
| svn_boolean_t ignore_ancestry, |
| svn_boolean_t show_copies_as_adds, |
| svn_boolean_t use_git_diff_format, |
| svn_boolean_t use_text_base, |
| svn_boolean_t reverse_order, |
| svn_boolean_t server_performs_filtering, |
| const apr_array_header_t *changelist_filter, |
| const svn_wc_diff_callbacks4_t *callbacks, |
| void *callback_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_get_diff_editor6(), but with an access baton and relative |
| * path. @a server_performs_filtering always true and with a |
| * #svn_wc_diff_callbacks3_t instead of #svn_wc_diff_callbacks4_t, |
| * @a show_copies_as_adds, and @a use_git_diff_format set to @c FALSE. |
| * |
| * Diffs will be reported as below the relative path stored in @a anchor. |
| * |
| * @since New in 1.6. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_diff_editor5(svn_wc_adm_access_t *anchor, |
| const char *target, |
| const svn_wc_diff_callbacks3_t *callbacks, |
| void *callback_baton, |
| svn_depth_t depth, |
| svn_boolean_t ignore_ancestry, |
| svn_boolean_t use_text_base, |
| svn_boolean_t reverse_order, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| const apr_array_header_t *changelist_filter, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_get_diff_editor5(), but with an |
| * #svn_wc_diff_callbacks2_t instead of #svn_wc_diff_callbacks3_t. |
| * |
| * @deprecated Provided for backward compatibility with the 1.5 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_diff_editor4(svn_wc_adm_access_t *anchor, |
| const char *target, |
| const svn_wc_diff_callbacks2_t *callbacks, |
| void *callback_baton, |
| svn_depth_t depth, |
| svn_boolean_t ignore_ancestry, |
| svn_boolean_t use_text_base, |
| svn_boolean_t reverse_order, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| const apr_array_header_t *changelist_filter, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_get_diff_editor4(), but with @a changelist_filter |
| * passed as @c NULL, and @a depth set to #svn_depth_infinity if @a |
| * recurse is TRUE, or #svn_depth_files if @a recurse is FALSE. |
| * |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| |
| * @since New in 1.2. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_diff_editor3(svn_wc_adm_access_t *anchor, |
| const char *target, |
| const svn_wc_diff_callbacks2_t *callbacks, |
| void *callback_baton, |
| svn_boolean_t recurse, |
| svn_boolean_t ignore_ancestry, |
| svn_boolean_t use_text_base, |
| svn_boolean_t reverse_order, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Similar to svn_wc_get_diff_editor3(), but with an |
| * #svn_wc_diff_callbacks_t instead of #svn_wc_diff_callbacks2_t. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_diff_editor2(svn_wc_adm_access_t *anchor, |
| const char *target, |
| const svn_wc_diff_callbacks_t *callbacks, |
| void *callback_baton, |
| svn_boolean_t recurse, |
| svn_boolean_t ignore_ancestry, |
| svn_boolean_t use_text_base, |
| svn_boolean_t reverse_order, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Similar to svn_wc_get_diff_editor2(), but with @a ignore_ancestry |
| * always set to @c FALSE. |
| * |
| * @deprecated Provided for backward compatibility with the 1.0 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_diff_editor(svn_wc_adm_access_t *anchor, |
| const char *target, |
| const svn_wc_diff_callbacks_t *callbacks, |
| void *callback_baton, |
| svn_boolean_t recurse, |
| svn_boolean_t use_text_base, |
| svn_boolean_t reverse_order, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| const svn_delta_editor_t **editor, |
| void **edit_baton, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Compare working copy against the text-base. |
| * |
| * @a target_abspath represents the base of the hierarchy to be compared. |
| * |
| * @a callbacks/@a callback_baton is the callback table to use when two |
| * files are to be compared. |
| * |
| * If @a depth is #svn_depth_empty, just diff exactly @a target_path. |
| * If #svn_depth_files then do the same |
| * and for top-level file entries as well (if any). If |
| * #svn_depth_immediates, do the same as #svn_depth_files but also diff |
| * top-level subdirectories at #svn_depth_empty. If #svn_depth_infinity, |
| * then diff fully recursively. |
| * |
| * @a ignore_ancestry determines whether paths that have discontinuous node |
| * ancestry are treated as delete/add or as simple modifications. If |
| * @a ignore_ancestry is @c FALSE, then any discontinuous node ancestry will |
| * result in the diff given as a full delete followed by an add. |
| * |
| * @a show_copies_as_adds determines whether paths added with history will |
| * appear as a diff against their copy source, or whether such paths will |
| * appear as if they were newly added in their entirety. |
| * |
| * If @a use_git_diff_format is TRUE, copied paths will be treated as added |
| * if they weren't modified after being copied. This allows the callbacks |
| * to generate appropriate --git diff headers for such files. |
| * |
| * @a changelist_filter is an array of <tt>const char *</tt> changelist |
| * names, used as a restrictive filter on items whose differences are |
| * reported; that is, don't generate diffs about any item unless |
| * it's a member of one of those changelists. If @a changelist_filter is |
| * empty (or altogether @c NULL), no changelist filtering occurs. |
| * |
| * If @a cancel_func is non-NULL, invoke it with @a cancel_baton at various |
| * points during the operation. If it returns an error (typically |
| * #SVN_ERR_CANCELLED), return that error immediately. |
| * |
| * For working copies that do not store local pristine contents for all |
| * files, return @c SVN_ERR_WC_PRISTINE_DEHYDRATED on an attempt to diff |
| * a file whose pristine contents is not present locally. |
| * |
| * @note For general purposes, please consider using APIs from svn_client.h, |
| * @see svn_client_diff7(). |
| * |
| * @note This is a relatively low-level function operating directly on a |
| * working copy, so a caller is expected to be able to handle working copies |
| * that do not store local copies of all pristine contents. This can be |
| * achieved by synchronizing the text-base state before and optionally |
| * after the function call. @see svn_wc_textbase_sync(). |
| * |
| * @since New in 1.15. |
| */ |
| svn_error_t * |
| svn_wc_diff7(svn_wc_context_t *wc_ctx, |
| const char *target_abspath, |
| const svn_wc_diff_callbacks4_t *callbacks, |
| void *callback_baton, |
| svn_depth_t depth, |
| svn_boolean_t ignore_ancestry, |
| svn_boolean_t show_copies_as_adds, |
| svn_boolean_t use_git_diff_format, |
| const apr_array_header_t *changelist_filter, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_diff7(), but this function can only be used for |
| * working copies that store local copies of all pristine contents. |
| * Otherwise, an #SVN_ERR_WC_DEPRECATED_API_STORE_PRISTINE error will be |
| * returned. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_diff6(svn_wc_context_t *wc_ctx, |
| const char *target_abspath, |
| const svn_wc_diff_callbacks4_t *callbacks, |
| void *callback_baton, |
| svn_depth_t depth, |
| svn_boolean_t ignore_ancestry, |
| svn_boolean_t show_copies_as_adds, |
| svn_boolean_t use_git_diff_format, |
| const apr_array_header_t *changelist_filter, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_diff6(), but with a #svn_wc_diff_callbacks3_t argument |
| * instead of #svn_wc_diff_callbacks4_t, @a show_copies_as_adds, |
| * and @a use_git_diff_format set to * @c FALSE. |
| * It also doesn't allow specifying a cancel function. |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_diff5(svn_wc_adm_access_t *anchor, |
| const char *target, |
| const svn_wc_diff_callbacks3_t *callbacks, |
| void *callback_baton, |
| svn_depth_t depth, |
| svn_boolean_t ignore_ancestry, |
| const apr_array_header_t *changelist_filter, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_diff5(), but with a #svn_wc_diff_callbacks2_t argument |
| * instead of #svn_wc_diff_callbacks3_t. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backward compatibility with the 1.5 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_diff4(svn_wc_adm_access_t *anchor, |
| const char *target, |
| const svn_wc_diff_callbacks2_t *callbacks, |
| void *callback_baton, |
| svn_depth_t depth, |
| svn_boolean_t ignore_ancestry, |
| const apr_array_header_t *changelist_filter, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_diff4(), but with @a changelist_filter passed @c NULL, |
| * and @a depth set to #svn_depth_infinity if @a recurse is TRUE, or |
| * #svn_depth_files if @a recurse is FALSE. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_diff3(svn_wc_adm_access_t *anchor, |
| const char *target, |
| const svn_wc_diff_callbacks2_t *callbacks, |
| void *callback_baton, |
| svn_boolean_t recurse, |
| svn_boolean_t ignore_ancestry, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_diff3(), but with a #svn_wc_diff_callbacks_t argument |
| * instead of #svn_wc_diff_callbacks2_t. |
| * |
| * @since New in 1.1. |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_diff2(svn_wc_adm_access_t *anchor, |
| const char *target, |
| const svn_wc_diff_callbacks_t *callbacks, |
| void *callback_baton, |
| svn_boolean_t recurse, |
| svn_boolean_t ignore_ancestry, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_diff2(), but with @a ignore_ancestry always set |
| * to @c FALSE. |
| * |
| * @deprecated Provided for backward compatibility with the 1.0 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_diff(svn_wc_adm_access_t *anchor, |
| const char *target, |
| const svn_wc_diff_callbacks_t *callbacks, |
| void *callback_baton, |
| svn_boolean_t recurse, |
| apr_pool_t *pool); |
| |
| |
| /** Given a @a local_abspath to a file or directory under version control, |
| * discover any local changes made to properties and/or the set of 'pristine' |
| * properties. @a wc_ctx will be used to access the working copy. |
| * |
| * If @a propchanges is non-@c NULL, return these changes as an array of |
| * #svn_prop_t structures stored in @a *propchanges. The structures and |
| * array will be allocated in @a result_pool. If there are no local property |
| * modifications on @a local_abspath, then set @a *propchanges will be empty. |
| * |
| * If @a original_props is non-@c NULL, then set @a *original_props to |
| * hashtable (<tt>const char *name</tt> -> <tt>const svn_string_t *value</tt>) |
| * that represents the 'pristine' property list of @a path. This hashtable is |
| * allocated in @a result_pool. |
| * |
| * Use @a scratch_pool for temporary allocations. |
| */ |
| svn_error_t * |
| svn_wc_get_prop_diffs2(apr_array_header_t **propchanges, |
| apr_hash_t **original_props, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_get_prop_diffs2(), but with a #svn_wc_adm_access_t / |
| * relative path parameter pair. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_prop_diffs(apr_array_header_t **propchanges, |
| apr_hash_t **original_props, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup svn_wc_merging Merging |
| * @{ |
| */ |
| |
| /** The outcome of a merge carried out (or tried as a dry-run) by |
| * svn_wc_merge() |
| */ |
| typedef enum svn_wc_merge_outcome_t |
| { |
| /** The working copy is (or would be) unchanged. The changes to be |
| * merged were already present in the working copy |
| */ |
| svn_wc_merge_unchanged, |
| |
| /** The working copy has been (or would be) changed. */ |
| svn_wc_merge_merged, |
| |
| /** The working copy has been (or would be) changed, but there was (or |
| * would be) a conflict |
| */ |
| svn_wc_merge_conflict, |
| |
| /** No merge was performed, probably because the target file was |
| * either absent or not under version control. |
| */ |
| svn_wc_merge_no_merge |
| |
| } svn_wc_merge_outcome_t; |
| |
| /** Given absolute paths to three fulltexts, merge the differences between |
| * @a left_abspath and @a right_abspath into @a target_abspath. |
| * It may help to know that @a left_abspath, @a right_abspath and @a |
| * target_abspath correspond to "OLDER", "YOURS", and "MINE", |
| * respectively, in the diff3 documentation. |
| * |
| * @a wc_ctx should contain a write lock for the directory containing @a |
| * target_abspath. |
| * |
| * This function assumes that @a left_abspath and @a right_abspath are |
| * in repository-normal form (linefeeds, with keywords contracted); if |
| * necessary, @a target_abspath is temporarily converted to this form to |
| * receive the changes, then translated back again. |
| * |
| * If @a target_abspath is absent, or present but not under version |
| * control, then set @a *merge_content_outcome to #svn_wc_merge_no_merge and |
| * return success without merging anything. (The reasoning is that if |
| * the file is not versioned, then it is probably unrelated to the |
| * changes being considered, so they should not be merged into it. |
| * Furthermore, merging into an unversioned file is a lossy operation.) |
| * |
| * @a dry_run determines whether the working copy is modified. When it |
| * is @c FALSE the merge will cause @a target_abspath to be modified, when |
| * it is @c TRUE the merge will be carried out to determine the result but |
| * @a target_abspath will not be modified. |
| * |
| * If @a diff3_cmd is non-NULL, then use it as the diff3 command for |
| * any merging; otherwise, use the built-in merge code. If @a |
| * merge_options is non-NULL, either pass its elements to @a diff3_cmd or |
| * parse it and use as options to the internal merge code (see |
| * svn_diff_file_options_parse()). @a merge_options must contain |
| * <tt>const char *</tt> elements. |
| * |
| * If @a merge_props_state is non-NULL, merge @a prop_diff into the |
| * working properties before merging the text. (If @a merge_props_state |
| * is NULL, do not merge any property changes; in this case, @a prop_diff |
| * is only used to help determine the text merge result.) Handle any |
| * conflicts as described for svn_wc_merge_props3(), with the parameters |
| * @a dry_run, @a conflict_func and @a conflict_baton. Return the |
| * outcome of the property merge in @a *merge_props_state. |
| * |
| * The outcome of the text merge is returned in @a *merge_content_outcome. If |
| * there is a conflict and @a dry_run is @c FALSE, then attempt to call @a |
| * conflict_func with @a conflict_baton (if non-NULL). If the |
| * conflict callback cannot resolve the conflict, then: |
| * |
| * * Put conflict markers around the conflicting regions in |
| * @a target_abspath, labeled with @a left_label, @a right_label, and |
| * @a target_label. (If any of these labels are @c NULL, default |
| * values will be used.) |
| * |
| * * Copy @a left_abspath, @a right_abspath, and the original @a |
| * target_abspath to unique names in the same directory as @a |
| * target_abspath, ending with the suffixes ".LEFT_LABEL", ".RIGHT_LABEL", |
| * and ".TARGET_LABEL" respectively. |
| * |
| * * Mark @a target_abspath as "text-conflicted", and track the above |
| * mentioned backup files as well. |
| * |
| * * If @a left_version and/or @a right_version are not NULL, provide |
| * these values to the conflict handler and track these while the conflict |
| * exists. |
| * |
| * Binary case: |
| * |
| * If @a target_abspath is a binary file, then no merging is attempted, |
| * the merge is deemed to be a conflict. If @a dry_run is @c FALSE the |
| * working @a target_abspath is untouched, and copies of @a left_abspath and |
| * @a right_abspath are created next to it using @a left_label and |
| * @a right_label. @a target_abspath is marked as "text-conflicted", and |
| * begins tracking the two backup files and the version information. |
| * |
| * If @a dry_run is @c TRUE no files are changed. The outcome of the merge |
| * is returned in @a *merge_content_outcome. |
| * ### (and what about @a *merge_props_state?) |
| * |
| * ### BH: Two kinds of outcome is not how it should be. |
| * |
| * ### For text, we report the outcome as 'merged' if there was some |
| * incoming change that we dealt with (even if we decided to no-op?) |
| * but the callers then convert this outcome into a notification |
| * of 'merged' only if there was already a local modification; |
| * otherwise they notify it as simply 'updated'. But for props |
| * we report a notify state of 'merged' here if there was an |
| * incoming change regardless of the local-mod state. Inconsistent. |
| * |
| * Use @a scratch_pool for any temporary allocation. |
| * |
| * For working copies that do not store local pristine contents for all |
| * files, return @c SVN_ERR_WC_PRISTINE_DEHYDRATED on an attempt to merge |
| * a file whose pristine contents is not present locally. |
| * |
| * @note This is a relatively low-level function operating directly on a |
| * working copy, so a caller is expected to be able to handle working copies |
| * that do not store local copies of all pristine contents. This can be |
| * achieved by synchronizing the text-base state before and optionally |
| * after the function call. @see svn_wc_textbase_sync(). |
| * |
| * @since New in 1.15. |
| */ |
| svn_error_t * |
| svn_wc_merge6(enum svn_wc_merge_outcome_t *merge_content_outcome, |
| enum svn_wc_notify_state_t *merge_props_state, |
| svn_wc_context_t *wc_ctx, |
| const char *left_abspath, |
| const char *right_abspath, |
| const char *target_abspath, |
| const char *left_label, |
| const char *right_label, |
| const char *target_label, |
| const svn_wc_conflict_version_t *left_version, |
| const svn_wc_conflict_version_t *right_version, |
| svn_boolean_t dry_run, |
| const char *diff3_cmd, |
| const apr_array_header_t *merge_options, |
| apr_hash_t *original_props, |
| const apr_array_header_t *prop_diff, |
| svn_wc_conflict_resolver_func2_t conflict_func, |
| void *conflict_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_merge6(), but this function can only be used |
| * for working copies that store local copies of all pristine contents. |
| * Otherwise, an #SVN_ERR_WC_DEPRECATED_API_STORE_PRISTINE error will be |
| * returned. |
| * |
| * @since New in 1.8. |
| * @deprecated Provided for backwards compatibility with the 1.8 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_merge5(enum svn_wc_merge_outcome_t *merge_content_outcome, |
| enum svn_wc_notify_state_t *merge_props_state, |
| svn_wc_context_t *wc_ctx, |
| const char *left_abspath, |
| const char *right_abspath, |
| const char *target_abspath, |
| const char *left_label, |
| const char *right_label, |
| const char *target_label, |
| const svn_wc_conflict_version_t *left_version, |
| const svn_wc_conflict_version_t *right_version, |
| svn_boolean_t dry_run, |
| const char *diff3_cmd, |
| const apr_array_header_t *merge_options, |
| apr_hash_t *original_props, |
| const apr_array_header_t *prop_diff, |
| svn_wc_conflict_resolver_func2_t conflict_func, |
| void *conflict_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_merge5() but with @a merge_props_state and @a |
| * original_props always passed as NULL. |
| * |
| * Unlike svn_wc_merge5(), this function doesn't merge property |
| * changes. Callers of this function must first use |
| * svn_wc_merge_props3() to get this functionality. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backwards compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_merge4(enum svn_wc_merge_outcome_t *merge_outcome, |
| svn_wc_context_t *wc_ctx, |
| const char *left_abspath, |
| const char *right_abspath, |
| const char *target_abspath, |
| const char *left_label, |
| const char *right_label, |
| const char *target_label, |
| const svn_wc_conflict_version_t *left_version, |
| const svn_wc_conflict_version_t *right_version, |
| svn_boolean_t dry_run, |
| const char *diff3_cmd, |
| const apr_array_header_t *merge_options, |
| const apr_array_header_t *prop_diff, |
| svn_wc_conflict_resolver_func2_t conflict_func, |
| void *conflict_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Similar to svn_wc_merge4() but takes relative paths and an access |
| * baton. It doesn't support a cancel function or tracking origin version |
| * information. |
| * |
| * Uses a svn_wc_conflict_resolver_func_t conflict resolver instead of a |
| * svn_wc_conflict_resolver_func2_t. |
| * |
| * This function assumes that @a diff3_cmd is path encoded. Later versions |
| * assume utf-8. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backwards compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_merge3(enum svn_wc_merge_outcome_t *merge_outcome, |
| const char *left, |
| const char *right, |
| const char *merge_target, |
| svn_wc_adm_access_t *adm_access, |
| const char *left_label, |
| const char *right_label, |
| const char *target_label, |
| svn_boolean_t dry_run, |
| const char *diff3_cmd, |
| const apr_array_header_t *merge_options, |
| const apr_array_header_t *prop_diff, |
| svn_wc_conflict_resolver_func_t conflict_func, |
| void *conflict_baton, |
| apr_pool_t *pool); |
| |
| |
| /** Similar to svn_wc_merge3(), but with @a prop_diff, @a |
| * conflict_func, @a conflict_baton set to NULL. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_merge2(enum svn_wc_merge_outcome_t *merge_outcome, |
| const char *left, |
| const char *right, |
| const char *merge_target, |
| svn_wc_adm_access_t *adm_access, |
| const char *left_label, |
| const char *right_label, |
| const char *target_label, |
| svn_boolean_t dry_run, |
| const char *diff3_cmd, |
| const apr_array_header_t *merge_options, |
| apr_pool_t *pool); |
| |
| |
| /** Similar to svn_wc_merge2(), but with @a merge_options set to NULL. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.3 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_merge(const char *left, |
| const char *right, |
| const char *merge_target, |
| svn_wc_adm_access_t *adm_access, |
| const char *left_label, |
| const char *right_label, |
| const char *target_label, |
| svn_boolean_t dry_run, |
| enum svn_wc_merge_outcome_t *merge_outcome, |
| const char *diff3_cmd, |
| apr_pool_t *pool); |
| |
| |
| /** Given a @a local_abspath under version control, merge an array of @a |
| * propchanges into the path's existing properties. @a propchanges is |
| * an array of #svn_prop_t objects, and @a baseprops is a hash |
| * representing the original set of properties that @a propchanges is |
| * working against. @a wc_ctx contains a lock for @a local_abspath. |
| * |
| * Only the working properties will be changed. |
| * |
| * If @a state is non-NULL, set @a *state to the state of the properties |
| * after the merge. |
| * |
| * If a conflict is found when merging a property, and @a dry_run is |
| * false and @a conflict_func is not null, then call @a conflict_func |
| * with @a conflict_baton and a description of the conflict. If any |
| * conflicts are not resolved by such callbacks, describe the unresolved |
| * conflicts in a temporary .prej file (or append to an already-existing |
| * .prej file) and mark the path as conflicted in the WC DB. |
| * |
| * If @a cancel_func is non-NULL, invoke it with @a cancel_baton at various |
| * points during the operation. If it returns an error (typically |
| * #SVN_ERR_CANCELLED), return that error immediately. |
| * |
| * If @a local_abspath is not under version control, return the error |
| * #SVN_ERR_WC_PATH_NOT_FOUND and don't touch anyone's properties. |
| * |
| * If @a local_abspath has a status in which it doesn't have properties |
| * (E.g. deleted) return the error SVN_ERR_WC_PATH_UNEXPECTED_STATUS. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_merge_props3(svn_wc_notify_state_t *state, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| const svn_wc_conflict_version_t *left_version, |
| const svn_wc_conflict_version_t *right_version, |
| apr_hash_t *baseprops, |
| const apr_array_header_t *propchanges, |
| svn_boolean_t dry_run, |
| svn_wc_conflict_resolver_func2_t conflict_func, |
| void *conflict_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Similar to svn_wc_merge_props3, but takes an access baton and relative |
| * path, no cancel_function, and no left and right version. |
| * |
| * This function has the @a base_merge parameter which (when TRUE) will |
| * apply @a propchanges to this node's pristine set of properties. This |
| * functionality is not supported since API version 1.7 and will give an |
| * error if requested (unless @a dry_run is TRUE). For details see |
| * 'notes/api-errata/1.7/wc006.txt'. |
| * |
| * Uses a svn_wc_conflict_resolver_func_t conflict resolver instead of a |
| * svn_wc_conflict_resolver_func2_t. |
| * |
| * For compatibility reasons this function returns |
| * #SVN_ERR_UNVERSIONED_RESOURCE, when svn_wc_merge_props3 would return either |
| * #SVN_ERR_WC_PATH_NOT_FOUND or #SVN_ERR_WC_PATH_UNEXPECTED_STATUS. |
| * |
| * @since New in 1.5. The base_merge option is not supported since 1.7. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_merge_props2(svn_wc_notify_state_t *state, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_hash_t *baseprops, |
| const apr_array_header_t *propchanges, |
| svn_boolean_t base_merge, |
| svn_boolean_t dry_run, |
| svn_wc_conflict_resolver_func_t conflict_func, |
| void *conflict_baton, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Same as svn_wc_merge_props2(), but with a @a conflict_func (and |
| * baton) of NULL. |
| * |
| * @since New in 1.3. The base_merge option is not supported since 1.7. |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_merge_props(svn_wc_notify_state_t *state, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_hash_t *baseprops, |
| const apr_array_header_t *propchanges, |
| svn_boolean_t base_merge, |
| svn_boolean_t dry_run, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Similar to svn_wc_merge_props(), but no baseprops are given. |
| * Instead, it's assumed that the incoming propchanges are based |
| * against the working copy's own baseprops. While this assumption is |
| * correct for 'svn update', it's incorrect for 'svn merge', and can |
| * cause flawed behavior. (See issue #2035.) |
| * |
| * @since The base_merge option is not supported since 1.7. |
| * @deprecated Provided for backward compatibility with the 1.2 API. |
| * Replaced by svn_wc_merge_props(). |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_merge_prop_diffs(svn_wc_notify_state_t *state, |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| const apr_array_header_t *propchanges, |
| svn_boolean_t base_merge, |
| svn_boolean_t dry_run, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** Given a @a path to a wc file, return in @a *contents a readonly stream to |
| * the pristine contents of the file that would serve as base content for the |
| * next commit. That means: |
| * |
| * When there is no change in node history scheduled, i.e. when there are only |
| * local text-mods, prop-mods or a delete, return the last checked-out or |
| * updated-/switched-to contents of the file. |
| * |
| * If the file is simply added or replaced (no copy-/move-here involved), |
| * set @a *contents to @c NULL. |
| * |
| * When the file has been locally copied-/moved-here, return the contents of |
| * the copy/move source (even if the copy-/move-here replaces a locally |
| * deleted file). |
| * |
| * If @a local_abspath refers to an unversioned or non-existent path, return |
| * @c SVN_ERR_WC_PATH_NOT_FOUND. Use @a wc_ctx to access the working copy. |
| * @a contents may not be @c NULL (unlike @a *contents). |
| * |
| * For working copies that do not store local pristine contents for all |
| * files, the function may return a detranslated stream to the contents |
| * of the file itself if the file is not modified. If the file is |
| * modified and its pristine contents is not present locally, return |
| * @c SVN_ERR_WC_PRISTINE_DEHYDRATED. |
| * |
| * @note This is a relatively low-level function operating directly on a |
| * working copy, so a caller is expected to be able to handle working copies |
| * that do not store local copies of all pristine contents. This can be |
| * achieved by synchronizing the text-base state before and optionally |
| * after the function call. @see svn_wc_textbase_sync(). |
| * |
| * @since New in 1.15. |
| */ |
| svn_error_t * |
| svn_wc_get_pristine_contents3(svn_stream_t **contents, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_get_pristine_contents3, but this function can only be used |
| * for working copies that store local copies of all pristine contents. |
| * Otherwise, an #SVN_ERR_WC_DEPRECATED_API_STORE_PRISTINE error will be |
| * returned. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_pristine_contents2(svn_stream_t **contents, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_get_pristine_contents2, but takes no working copy |
| * context and a path that can be relative |
| * |
| * @since New in 1.6. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_pristine_contents(svn_stream_t **contents, |
| const char *path, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Set @a *pristine_path to the path of the "normal" pristine text file for |
| * the versioned file @a path. |
| * |
| * If @a path does not have a pristine text, set @a *pristine_path to a path where |
| * nothing exists on disk (in a directory that does exist). |
| * |
| * @note: Before version 1.7, the behaviour in that case was to provide the |
| * path where the pristine text *would be* if it were present. The new |
| * behaviour is intended to provide backward compatibility for callers that |
| * open or test the provided path immediately, and not for callers that |
| * store the path for later use. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.5 API. |
| * Callers should use svn_wc_get_pristine_contents() instead. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_pristine_copy_path(const char *path, |
| const char **pristine_path, |
| apr_pool_t *pool); |
| |
| |
| /** The callback invoked by svn_wc_textbase_sync() to provide the text-base |
| * contents identified by @a repos_root_url, @a repos_relpath and @a revision. |
| * |
| * The callback is expected to write the contents to @a contents and close |
| * the stream. |
| * |
| * @since New in 1.15. |
| */ |
| typedef svn_error_t *(*svn_wc_textbase_fetch_cb_t)( |
| void *baton, |
| const char *repos_root_url, |
| const char *repos_relpath, |
| svn_revnum_t revision, |
| svn_stream_t *contents, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Synchronize the state of the text-base contents for the |
| * @a local_abspath tree. |
| * |
| * If @a allow_hydrate is true, fetch the required but missing text-base |
| * contents using the provided @a fetch_callback and @a fetch_baton. |
| * If @a allow_hydrate is false, @a fetch_callback will not be used and |
| * may be @c NULL. |
| * |
| * If @a allow_dehydrate is true, remove the on disk text-base contents |
| * that is not required. |
| * |
| * If @a cancel_func is non-NULL, invoke it with @a cancel_baton at various |
| * points during the operation. If it returns an error (typically |
| * #SVN_ERR_CANCELLED), return that error immediately. |
| * |
| * If @a notify_func is non-NULL, invoke it with @a notify_baton to report |
| * the progress of the operation. |
| * |
| * @see svn_wc_textbase_fetch_cb_t |
| * @see svn_client__textbase_sync for usage/implementation example. |
| * |
| * @since New in 1.15. |
| */ |
| svn_error_t * |
| svn_wc_textbase_sync(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_boolean_t allow_hydrate, |
| svn_boolean_t allow_dehydrate, |
| svn_wc_textbase_fetch_cb_t fetch_callback, |
| void *fetch_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Recurse from @a local_abspath, cleaning up unfinished tasks. Perform |
| * any temporary allocations in @a scratch_pool. If @a break_locks is TRUE |
| * Any working copy locks under @a local_abspath will be taken over and then |
| * cleared by this function. |
| * WARNING: If @a break_locks is TRUE there is no mechanism that will protect |
| * locks that are still being used. |
| * |
| * If @a fix_recorded_timestamps is TRUE the recorded timestamps of unmodified |
| * files will be updated, which will improve performance of future is-modified |
| * checks. |
| * |
| * If @a clear_dav_cache is @c TRUE, the caching of DAV information for older |
| * mod_dav served repositories is cleared. This clearing invalidates some |
| * cached information used for pre-HTTPv2 repositories. |
| * |
| * If @a vacuum_pristines is TRUE, try to remove unreferenced pristines from |
| * the working copy. (Will not remove anything unless the obtained lock applies |
| * to the entire working copy) |
| * |
| * If @a cancel_func is non-NULL, invoke it with @a cancel_baton at various |
| * points during the operation. If it returns an error (typically |
| * #SVN_ERR_CANCELLED), return that error immediately. |
| * |
| * If @a notify_func is non-NULL, invoke it with @a notify_baton to report |
| * the progress of the operation. |
| * |
| * @note In 1.9, @a notify_func does not get called at all. This may change |
| * in later releases. |
| * |
| * @since New in 1.9. |
| */ |
| svn_error_t * |
| svn_wc_cleanup4(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_boolean_t break_locks, |
| svn_boolean_t fix_recorded_timestamps, |
| svn_boolean_t clear_dav_cache, |
| svn_boolean_t vacuum_pristines, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_cleanup4() but will always break locks, fix recorded |
| * timestamps, clear the dav cache and vacuum pristines. This function also |
| * doesn't support notifications. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.8 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_cleanup3(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_cleanup3() but uses relative paths and creates its own |
| * #svn_wc_context_t. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_cleanup2(const char *path, |
| const char *diff3_cmd, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_cleanup2(). @a optional_adm_access is an historic |
| * relic and not used, it may be NULL. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_cleanup(const char *path, |
| svn_wc_adm_access_t *optional_adm_access, |
| const char *diff3_cmd, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| /** Callback for retrieving a repository root for a url from upgrade. |
| * |
| * Called by svn_wc_upgrade() when no repository root and/or repository |
| * uuid are recorded in the working copy. For normal Subversion 1.5 and |
| * later working copies, this callback will not be used. |
| * |
| * @since New in 1.7. |
| */ |
| typedef svn_error_t * (*svn_wc_upgrade_get_repos_info_t)( |
| const char **repos_root, |
| const char **repos_uuid, |
| void *baton, |
| const char *url, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** |
| * Upgrade the working copy at @a local_abspath to the library's |
| * default metadata storage format (#SVN_WC__DEFAULT_VERSION). |
| * @a local_abspath should be an absolute path to the root of the |
| * working copy. |
| * |
| * If @a cancel_func is non-NULL, invoke it with @a cancel_baton at |
| * various points during the operation. If it returns an error |
| * (typically #SVN_ERR_CANCELLED), return that error immediately. |
| * |
| * For each directory converted, @a notify_func will be called with |
| * in @a notify_baton action #svn_wc_notify_upgraded_path and as path |
| * the path of the upgraded directory. @a notify_func may be @c NULL |
| * if this notification is not needed. |
| * |
| * If the old working copy doesn't contain a repository root and/or |
| * repository uuid, @a repos_info_func (if non-NULL) will be called |
| * with @a repos_info_baton to provide the missing information. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.14 API. |
| * @see svn_wc__upgrade() |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_upgrade(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_wc_upgrade_get_repos_info_t repos_info_func, |
| void *repos_info_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Relocation validation callback typedef. |
| * |
| * Called for each relocated file/directory. @a uuid, if non-NULL, contains |
| * the expected repository UUID, @a url contains the tentative URL. |
| * |
| * @a baton is a closure object; it should be provided by the |
| * implementation, and passed by the caller. |
| * |
| * If @a root_url is passed, then the implementation should make sure that |
| * @a url is the repository root. |
| * @a pool may be used for temporary allocations. |
| * |
| * @since New in 1.5. |
| */ |
| typedef svn_error_t *(*svn_wc_relocation_validator3_t)(void *baton, |
| const char *uuid, |
| const char *url, |
| const char *root_url, |
| apr_pool_t *pool); |
| |
| /** Similar to #svn_wc_relocation_validator3_t, but with |
| * the @a root argument. |
| * |
| * If @a root is TRUE, then the implementation should make sure that @a url |
| * is the repository root. Else, it can be a URL inside the repository. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.4 API. |
| */ |
| typedef svn_error_t *(*svn_wc_relocation_validator2_t)(void *baton, |
| const char *uuid, |
| const char *url, |
| svn_boolean_t root, |
| apr_pool_t *pool); |
| |
| /** Similar to #svn_wc_relocation_validator2_t, but without |
| * the @a root and @a pool arguments. @a uuid will not be NULL in this version |
| * of the function. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.3 API. |
| */ |
| typedef svn_error_t *(*svn_wc_relocation_validator_t)(void *baton, |
| const char *uuid, |
| const char *url); |
| |
| /** Recursively change repository references at @a wcroot_abspath |
| * (which is the root directory of a working copy). The pre-change |
| * URL should begin with @a from, and the post-change URL will begin |
| * with @a to. @a validator (and its baton, @a validator_baton), will |
| * be called for the newly generated base URL and calculated repo |
| * root. |
| * |
| * @a wc_ctx is an working copy context. |
| * |
| * @a scratch_pool will be used for temporary allocations. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_relocate4(svn_wc_context_t *wc_ctx, |
| const char *wcroot_abspath, |
| const char *from, |
| const char *to, |
| svn_wc_relocation_validator3_t validator, |
| void *validator_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_relocate4(), but with a #svn_wc_adm_access_t / |
| * relative path parameter pair. |
| * |
| * @note As of the 1.7 API, @a path is required to be a working copy |
| * root directory, and @a recurse is required to be TRUE. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for limited backwards compatibility with the |
| * 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_relocate3(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| const char *from, |
| const char *to, |
| svn_boolean_t recurse, |
| svn_wc_relocation_validator3_t validator, |
| void *validator_baton, |
| apr_pool_t *pool); |
| |
| /** Similar to svn_wc_relocate3(), but uses #svn_wc_relocation_validator2_t. |
| * |
| * @since New in 1.4. |
| * @deprecated Provided for backwards compatibility with the 1.4 API. */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_relocate2(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| const char *from, |
| const char *to, |
| svn_boolean_t recurse, |
| svn_wc_relocation_validator2_t validator, |
| void *validator_baton, |
| apr_pool_t *pool); |
| |
| /** Similar to svn_wc_relocate2(), but uses #svn_wc_relocation_validator_t. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.3 API. */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_relocate(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| const char *from, |
| const char *to, |
| svn_boolean_t recurse, |
| svn_wc_relocation_validator_t validator, |
| void *validator_baton, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Revert changes to @a local_abspath. Perform necessary allocations in |
| * @a scratch_pool. |
| * |
| * @a wc_ctx contains the necessary locks required for performing the |
| * operation. |
| * |
| * If @a depth is #svn_depth_empty, revert just @a path (if a |
| * directory, then revert just the properties on that directory). |
| * Else if #svn_depth_files, revert @a path and any files |
| * directly under @a path if it is directory. Else if |
| * #svn_depth_immediates, revert all of the preceding plus |
| * properties on immediate subdirectories; else if #svn_depth_infinity, |
| * revert path and everything under it fully recursively. |
| * |
| * @a changelist_filter is an array of <tt>const char *</tt> changelist |
| * names, used as a restrictive filter on items reverted; that is, |
| * don't revert any item unless it's a member of one of those |
| * changelists. If @a changelist_filter is empty (or altogether @c NULL), |
| * no changelist filtering occurs. |
| * |
| * If @a clear_changelists is TRUE, then changelist information for the |
| * paths is cleared. |
| * |
| * The @a metadata_only and @a added_keep_local options control the |
| * extent of reverting. If @a metadata_only is TRUE, the working copy |
| * files are untouched, but if there are conflict marker files attached |
| * to these files these markers are removed. Otherwise, if |
| * @a added_keep_local is TRUE, then all items are reverted except an |
| * item that was scheduled as plain 'add' (not a copy) will not be |
| * removed from the working copy. Otherwise, all items are reverted and |
| * their on-disk state changed to match. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton at |
| * various points during the reversion process. If it returns an |
| * error (typically #SVN_ERR_CANCELLED), return that error |
| * immediately. |
| * |
| * If @a use_commit_times is TRUE, then all reverted working-files |
| * will have their timestamp set to the last-committed-time. If |
| * FALSE, the reverted working-files will be touched with the 'now' time. |
| * |
| * For each item reverted, @a notify_func will be called with @a notify_baton |
| * and the path of the reverted item. @a notify_func may be @c NULL if this |
| * notification is not needed. |
| * |
| * If @a path is not under version control, return the error |
| * #SVN_ERR_UNVERSIONED_RESOURCE. |
| * |
| * For working copies that do not store local pristine contents for all |
| * files, return @c SVN_ERR_WC_PRISTINE_DEHYDRATED on an attempt to revert |
| * a file whose pristine contents is not present locally. |
| * |
| * @note For general purposes, please consider using APIs from svn_client.h, |
| * @see svn_client_revert4(). |
| * |
| * @note This is a relatively low-level function operating directly on a |
| * working copy, so a caller is expected to be able to handle working copies |
| * that do not store local copies of all pristine contents. This can be |
| * achieved by synchronizing the text-base state before and optionally |
| * after the function call. @see svn_wc_textbase_sync(). |
| * |
| * @since New in 1.15. |
| */ |
| svn_error_t * |
| svn_wc_revert7(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_depth_t depth, |
| svn_boolean_t use_commit_times, |
| const apr_array_header_t *changelist_filter, |
| svn_boolean_t clear_changelists, |
| svn_boolean_t metadata_only, |
| svn_boolean_t added_keep_local, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_revert7(), but this function can only be used |
| * for working copies that store local copies of all pristine contents. |
| * Otherwise, an #SVN_ERR_WC_DEPRECATED_API_STORE_PRISTINE error will be |
| * returned. |
| * |
| * @since New in 1.11. |
| * @deprecated Provided for backward compatibility with the 1.11 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_revert6(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_depth_t depth, |
| svn_boolean_t use_commit_times, |
| const apr_array_header_t *changelist_filter, |
| svn_boolean_t clear_changelists, |
| svn_boolean_t metadata_only, |
| svn_boolean_t added_keep_local, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_revert6() but with @a added_keep_local always |
| * set to TRUE. |
| * |
| * @since New in 1.9. |
| * @deprecated Provided for backward compatibility with the 1.10 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_revert5(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_depth_t depth, |
| svn_boolean_t use_commit_times, |
| const apr_array_header_t *changelist_filter, |
| svn_boolean_t clear_changelists, |
| svn_boolean_t metadata_only, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_revert5() but with @a clear_changelists always set to |
| * FALSE and @a metadata_only set to FALSE. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.8 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_revert4(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_depth_t depth, |
| svn_boolean_t use_commit_times, |
| const apr_array_header_t *changelist_filter, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_revert4() but takes a relative path and access baton. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_revert3(const char *path, |
| svn_wc_adm_access_t *parent_access, |
| svn_depth_t depth, |
| svn_boolean_t use_commit_times, |
| const apr_array_header_t *changelist_filter, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_revert3(), but with @a changelist_filter passed as @c |
| * NULL, and @a depth set according to @a recursive: if @a recursive |
| * is TRUE, @a depth is #svn_depth_infinity; if FALSE, @a depth is |
| * #svn_depth_empty. |
| * |
| * @note Most APIs map @a recurse==FALSE to @a depth==svn_depth_files; |
| * revert is deliberately different. |
| * |
| * @since New in 1.2. |
| * @deprecated Provided for backward compatibility with the 1.4 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_revert2(const char *path, |
| svn_wc_adm_access_t *parent_access, |
| svn_boolean_t recursive, |
| svn_boolean_t use_commit_times, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Similar to svn_wc_revert2(), but takes an #svn_wc_notify_func_t instead. |
| * |
| * @deprecated Provided for backward compatibility with the 1.1 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_revert(const char *path, |
| svn_wc_adm_access_t *parent_access, |
| svn_boolean_t recursive, |
| svn_boolean_t use_commit_times, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| /** |
| * Restores a missing node, @a local_abspath using the @a wc_ctx. Records |
| * the new last modified time of the file for status processing. |
| * |
| * If @a use_commit_times is TRUE, then set restored files' timestamps |
| * to their last-commit-times. |
| * |
| * Returns SVN_ERROR_WC_PATH_NOT_FOUND if LOCAL_ABSPATH is not versioned and |
| * SVN_ERROR_WC_PATH_UNEXPECTED_STATUS if LOCAL_ABSPATH is in a status where |
| * it can't be restored. |
| * |
| * For working copies that do not store local pristine contents for all |
| * files, return @c SVN_ERR_WC_PRISTINE_DEHYDRATED on an attempt to restore |
| * a file whose pristine contents is not present locally. |
| * |
| * @note This is a relatively low-level function operating directly on a |
| * working copy, so a caller is expected to be able to handle working copies |
| * that do not store local copies of all pristine contents. This can be |
| * achieved by synchronizing the text-base state before and optionally |
| * after the function call. @see svn_wc_textbase_sync(). |
| * |
| * @since New in 1.15. |
| */ |
| svn_error_t * |
| svn_wc_restore2(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_boolean_t use_commit_times, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_restore2(), but this function can only be used |
| * for working copies that store local copies of all pristine contents. |
| * Otherwise, an #SVN_ERR_WC_DEPRECATED_API_STORE_PRISTINE error will be |
| * returned. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_restore(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_boolean_t use_commit_times, |
| apr_pool_t *scratch_pool); |
| |
| |
| /* Tmp files */ |
| |
| /** Create a unique temporary file in administrative tmp/ area of |
| * directory @a path. Return a handle in @a *fp and the path |
| * in @a *new_name. Either @a fp or @a new_name can be NULL. |
| * |
| * The flags will be <tt>APR_WRITE | APR_CREATE | APR_EXCL</tt> and |
| * optionally @c APR_DELONCLOSE (if the @a delete_when argument is |
| * set to #svn_io_file_del_on_close). |
| * |
| * This means that as soon as @a fp is closed, the tmp file will vanish. |
| * |
| * @since New in 1.4 |
| * @deprecated For compatibility with 1.6 API |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_create_tmp_file2(apr_file_t **fp, |
| const char **new_name, |
| const char *path, |
| svn_io_file_del_t delete_when, |
| apr_pool_t *pool); |
| |
| |
| /** Same as svn_wc_create_tmp_file2(), but with @a new_name set to @c NULL, |
| * and without the ability to delete the file on pool cleanup. |
| * |
| * @deprecated For compatibility with 1.3 API |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_create_tmp_file(apr_file_t **fp, |
| const char *path, |
| svn_boolean_t delete_on_close, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * @defgroup svn_wc_translate EOL conversion and keyword expansion |
| * @{ |
| */ |
| |
| |
| /** Set @a xlated_path to a translated copy of @a src |
| * or to @a src itself if no translation is necessary. |
| * That is, if @a versioned_file's properties indicate newline conversion or |
| * keyword expansion, point @a *xlated_path to a copy of @a src |
| * whose newlines and keywords are converted using the translation |
| * as requested by @a flags. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine |
| * if the client has canceled the operation. |
| * |
| * When translating to the normal form, inconsistent eol styles will be |
| * repaired when appropriate for the given setting. When translating |
| * from normal form, no EOL repair is performed (consistency is assumed). |
| * This behaviour can be overridden by specifying |
| * #SVN_WC_TRANSLATE_FORCE_EOL_REPAIR. |
| * |
| * The caller can explicitly request a new file to be returned by setting the |
| * #SVN_WC_TRANSLATE_FORCE_COPY flag in @a flags. |
| * |
| * This function is generally used to get a file that can be compared |
| * meaningfully against @a versioned_file's text base, if |
| * @c SVN_WC_TRANSLATE_TO_NF is specified, against @a versioned_file itself |
| * if @c SVN_WC_TRANSLATE_FROM_NF is specified. |
| * |
| * If a new output file is created, it is created in the temp file area |
| * belonging to @a versioned_file. By default it will be deleted at pool |
| * cleanup. If @c SVN_WC_TRANSLATE_NO_OUTPUT_CLEANUP is specified, the |
| * default pool cleanup handler to remove @a *xlated_path is not registered. |
| * If the input file is returned as the output, its lifetime is not |
| * specified. |
| * |
| * If an error is returned, the effect on @a *xlated_path is undefined. |
| * |
| * @since New in 1.4 |
| * @deprecated Provided for compatibility with the 1.6 API |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_translated_file2(const char **xlated_path, |
| const char *src, |
| const char *versioned_file, |
| svn_wc_adm_access_t *adm_access, |
| apr_uint32_t flags, |
| apr_pool_t *pool); |
| |
| |
| /** Same as svn_wc_translated_file2, but will never clean up |
| * temporary files. |
| * |
| * @deprecated Provided for compatibility with the 1.3 API |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_translated_file(const char **xlated_p, |
| const char *vfile, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t force_repair, |
| apr_pool_t *pool); |
| |
| |
| /** Returns a @a stream allocated in @a pool with access to the given |
| * @a path taking the file properties from @a versioned_file using |
| * @a adm_access. |
| * |
| * If @a flags includes #SVN_WC_TRANSLATE_FROM_NF, the stream will |
| * translate from Normal Form to working copy form while writing to |
| * @a path; stream read operations are not supported. |
| * Conversely, if @a flags includes #SVN_WC_TRANSLATE_TO_NF, the stream will |
| * translate from working copy form to Normal Form while reading from |
| * @a path; stream write operations are not supported. |
| * |
| * The @a flags are the same constants as those used for |
| * svn_wc_translated_file2(). |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_translated_stream(svn_stream_t **stream, |
| const char *path, |
| const char *versioned_file, |
| svn_wc_adm_access_t *adm_access, |
| apr_uint32_t flags, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup svn_wc_deltas Text/Prop Deltas Using an Editor |
| * @{ |
| */ |
| |
| /** Send the local modifications for versioned file @a local_abspath (with |
| * matching @a file_baton) through @a editor, then close @a file_baton |
| * afterwards. Use @a scratch_pool for any temporary allocation. |
| * |
| * If @a new_text_base_md5_checksum is non-NULL, set |
| * @a *new_text_base_md5_checksum to the MD5 checksum of (@a local_abspath |
| * translated to repository-normal form), allocated in @a result_pool. |
| * |
| * If @a new_text_base_sha1_checksum in non-NULL, store a copy of (@a |
| * local_abspath translated to repository-normal form) in the pristine text |
| * store, and set @a *new_text_base_sha1_checksum to its SHA-1 checksum. |
| * |
| * If @a fulltext, send the untranslated copy of @a local_abspath through |
| * @a editor as full-text; else send it as svndiff against the current text |
| * base. |
| * |
| * If sending a diff, and the recorded checksum for @a local_abspath's |
| * text-base does not match the current actual checksum, then remove the tmp |
| * copy (and set @a *tempfile to NULL if appropriate), and return the |
| * error #SVN_ERR_WC_CORRUPT_TEXT_BASE. |
| * |
| * @note This is intended for use with both infix and postfix |
| * text-delta styled editor drivers. |
| * |
| * @note For general purposes, please consider using APIs from svn_client.h, |
| * @see svn_client_commit6(). |
| * |
| * @note This is a relatively low-level function operating directly on a |
| * working copy, so a caller is expected to be able to handle working copies |
| * that do not store local copies of all pristine contents. This can be |
| * achieved by synchronizing the text-base state before and optionally |
| * after the function call. @see svn_wc_textbase_sync(). |
| * |
| * @since New in 1.15. |
| */ |
| svn_error_t * |
| svn_wc_transmit_text_deltas4(const svn_checksum_t **new_text_base_md5_checksum, |
| const svn_checksum_t **new_text_base_sha1_checksum, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_boolean_t fulltext, |
| const svn_delta_editor_t *editor, |
| void *file_baton, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_transmit_text_deltas4(), but this function can only be |
| * used for working copies that store local copies of all pristine contents. |
| * Otherwise, an #SVN_ERR_WC_DEPRECATED_API_STORE_PRISTINE error will be |
| * returned. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backwards compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_transmit_text_deltas3(const svn_checksum_t **new_text_base_md5_checksum, |
| const svn_checksum_t **new_text_base_sha1_checksum, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_boolean_t fulltext, |
| const svn_delta_editor_t *editor, |
| void *file_baton, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_transmit_text_deltas3(), but with a relative path |
| * and adm_access baton, and the checksum output is an MD5 digest instead of |
| * two svn_checksum_t objects. |
| * |
| * If @a tempfile is non-NULL, make a copy of @a path with keywords |
| * and eol translated to repository-normal form, and set @a *tempfile to the |
| * absolute path to this copy, allocated in @a result_pool. The copy will |
| * be in the temporary-text-base directory. Do not clean up the copy; |
| * caller can do that. (The purpose of handing back the tmp copy is that it |
| * is usually about to become the new text base anyway, but the installation |
| * of the new text base is outside the scope of this function.) |
| * |
| * @since New in 1.4. |
| * @deprecated Provided for backwards compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_transmit_text_deltas2(const char **tempfile, |
| unsigned char digest[], |
| const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t fulltext, |
| const svn_delta_editor_t *editor, |
| void *file_baton, |
| apr_pool_t *pool); |
| |
| /** Similar to svn_wc_transmit_text_deltas2(), but with @a digest set to NULL. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.3 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_transmit_text_deltas(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| svn_boolean_t fulltext, |
| const svn_delta_editor_t *editor, |
| void *file_baton, |
| const char **tempfile, |
| apr_pool_t *pool); |
| |
| |
| /** Given a @a local_abspath, transmit all local property |
| * modifications using the appropriate @a editor method (in conjunction |
| * with @a baton). Use @a scratch_pool for any temporary allocation. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_transmit_prop_deltas2(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| const svn_delta_editor_t *editor, |
| void *baton, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Similar to svn_wc_transmit_prop_deltas2(), but with a relative path, |
| * adm_access baton and tempfile. |
| * |
| * If a temporary file remains after this function is finished, the |
| * path to that file is returned in @a *tempfile (so the caller can |
| * clean this up if it wishes to do so). |
| * |
| * @note Starting version 1.5, no tempfile will ever be returned |
| * anymore. If @a *tempfile is passed, its value is set to @c NULL. |
| * |
| * @deprecated Provided for backwards compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_transmit_prop_deltas(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| const svn_wc_entry_t *entry, |
| const svn_delta_editor_t *editor, |
| void *baton, |
| const char **tempfile, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup svn_wc_ignore Ignoring unversioned files and directories |
| * @{ |
| */ |
| |
| /** Get the run-time configured list of ignore patterns from the |
| * #svn_config_t's in the @a config hash, and store them in @a *patterns. |
| * Allocate @a *patterns and its contents in @a pool. |
| */ |
| svn_error_t * |
| svn_wc_get_default_ignores(apr_array_header_t **patterns, |
| apr_hash_t *config, |
| apr_pool_t *pool); |
| |
| /** Get the list of ignore patterns from the #svn_config_t's in the |
| * @a config hash and the local ignore patterns from the directory |
| * at @a local_abspath, using @a wc_ctx, and store them in @a *patterns. |
| * Allocate @a *patterns and its contents in @a result_pool, use @a |
| * scratch_pool for temporary allocations. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_get_ignores2(apr_array_header_t **patterns, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_hash_t *config, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_get_ignores2(), but with a #svn_wc_adm_access_t |
| * parameter in place of #svn_wc_context_t and @c local_abspath parameters. |
| * |
| * @since New in 1.3. |
| * @deprecated Provided for backwards compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_get_ignores(apr_array_header_t **patterns, |
| apr_hash_t *config, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| /** Return TRUE iff @a str matches any of the elements of @a list, a |
| * list of zero or more ignore patterns. |
| * |
| * @since New in 1.5. |
| */ |
| svn_boolean_t |
| svn_wc_match_ignore_list(const char *str, |
| const apr_array_header_t *list, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup svn_wc_repos_locks Repository locks |
| * @{ |
| */ |
| |
| /** Add @a lock to the working copy for @a local_abspath. If @a |
| * local_abspath is read-only, due to locking properties, make it writable. |
| * Perform temporary allocations in @a scratch_pool. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_add_lock2(svn_wc_context_t *wc_ctx, |
| const char *abspath, |
| const svn_lock_t *lock, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_add_lock2(), but with a #svn_wc_adm_access_t / |
| * relative path parameter pair. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| * @since New in 1.2. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_add_lock(const char *path, |
| const svn_lock_t *lock, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| /** Remove any lock from @a local_abspath. If @a local_abspath has a |
| * lock and the locking so specifies, make the file read-only. Don't |
| * return an error if @a local_abspath didn't have a lock. Perform temporary |
| * allocations in @a scratch_pool. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_remove_lock2(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| apr_pool_t *scratch_pool); |
| |
| /** |
| * Similar to svn_wc_remove_lock2(), but with a #svn_wc_adm_access_t / |
| * relative path parameter pair. |
| * |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| * @since New in 1.2. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_remove_lock(const char *path, |
| svn_wc_adm_access_t *adm_access, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** A structure to report a summary of a working copy, including the |
| * mix of revisions found within it, whether any parts are switched or |
| * locally modified, and whether it is a sparse checkout. |
| * |
| * @note Fields may be added to the end of this structure in future |
| * versions. Therefore, to preserve binary compatibility, users |
| * should not directly allocate structures of this type. |
| * |
| * @since New in 1.4 |
| */ |
| typedef struct svn_wc_revision_status_t |
| { |
| svn_revnum_t min_rev; /**< Lowest revision found */ |
| svn_revnum_t max_rev; /**< Highest revision found */ |
| |
| svn_boolean_t switched; /**< Is anything switched? */ |
| svn_boolean_t modified; /**< Is anything modified? */ |
| |
| /** Whether any WC paths are at a depth other than #svn_depth_infinity or |
| * are user excluded. |
| * @since New in 1.5. |
| */ |
| svn_boolean_t sparse_checkout; |
| } svn_wc_revision_status_t; |
| |
| /** Set @a *result_p to point to a new #svn_wc_revision_status_t structure |
| * containing a summary of the revision range and status of the working copy |
| * at @a local_abspath (not including "externals"). @a local_abspath must |
| * be absolute. Return SVN_ERR_WC_PATH_NOT_FOUND if @a local_abspath is not |
| * a working copy path. |
| * |
| * Set @a (*result_p)->min_rev and @a (*result_p)->max_rev respectively to the |
| * lowest and highest revision numbers in the working copy. If @a committed |
| * is TRUE, summarize the last-changed revisions, else the base revisions. |
| * |
| * Set @a (*result_p)->switched to indicate whether any item in the WC is |
| * switched relative to its parent. If @a trail_url is non-NULL, use it to |
| * determine if @a local_abspath itself is switched. It should be any trailing |
| * portion of @a local_abspath's expected URL, long enough to include any parts |
| * that the caller considers might be changed by a switch. If it does not |
| * match the end of @a local_abspath's actual URL, then report a "switched" |
| * status. |
| * |
| * Set @a (*result_p)->modified to indicate whether any item is locally |
| * modified. |
| * |
| * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine |
| * if the client has canceled the operation. |
| * |
| * Allocate *result_p in @a result_pool, use @a scratch_pool for temporary |
| * allocations. |
| * |
| * @a wc_ctx should be a valid working copy context. |
| * |
| * @since New in 1.7 |
| */ |
| svn_error_t * |
| svn_wc_revision_status2(svn_wc_revision_status_t **result_p, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| const char *trail_url, |
| svn_boolean_t committed, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Similar to svn_wc_revision_status2(), but with a (possibly) local |
| * path and no wc_ctx parameter. |
| * |
| * @since New in 1.4. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_revision_status(svn_wc_revision_status_t **result_p, |
| const char *wc_path, |
| const char *trail_url, |
| svn_boolean_t committed, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Set @a local_abspath's 'changelist' attribute to @a changelist iff |
| * @a changelist is not @c NULL; otherwise, remove any current |
| * changelist assignment from @a local_abspath. @a changelist may not |
| * be the empty string. Recurse to @a depth. |
| * |
| * @a changelist_filter is an array of <tt>const char *</tt> changelist |
| * names, used as a restrictive filter on items whose changelist |
| * assignments are adjusted; that is, don't tweak the changeset of any |
| * item unless it's currently a member of one of those changelists. |
| * If @a changelist_filter is empty (or altogether @c NULL), no changelist |
| * filtering occurs. |
| * |
| * If @a cancel_func is not @c NULL, call it with @a cancel_baton to |
| * determine if the client has canceled the operation. |
| * |
| * If @a notify_func is not @c NULL, call it with @a notify_baton to |
| * report the change (using notification types |
| * #svn_wc_notify_changelist_set and #svn_wc_notify_changelist_clear). |
| * |
| * Use @a scratch_pool for temporary allocations. |
| * |
| * @note For now, directories are NOT allowed to be associated with |
| * changelists; there is confusion about whether they should behave |
| * as depth-0 or depth-infinity objects. If @a local_abspath is a directory, |
| * return an error. |
| * |
| * @note This metadata is purely a client-side "bookkeeping" |
| * convenience, and is entirely managed by the working copy. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_set_changelist2(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| const char *changelist, |
| svn_depth_t depth, |
| const apr_array_header_t *changelist_filter, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_set_changelist2(), but with an access baton and |
| * relative path. |
| * |
| * @since New in 1.5. |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_set_changelist(const char *path, |
| const char *changelist, |
| svn_wc_adm_access_t *adm_access, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *pool); |
| |
| |
| |
| /** |
| * The callback type used by svn_wc_get_changelists() and |
| * svn_client_get_changelists(). |
| * |
| * On each invocation, @a path is a newly discovered member of the |
| * changelist, and @a baton is a private function closure. |
| * |
| * @since New in 1.5. |
| */ |
| typedef svn_error_t *(*svn_changelist_receiver_t) (void *baton, |
| const char *path, |
| const char *changelist, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * Beginning at @a local_abspath, crawl to @a depth to discover every path in |
| * or under @a local_abspath which belongs to one of the changelists in @a |
| * changelist_filter (an array of <tt>const char *</tt> changelist names). |
| * If @a changelist_filter is @c NULL, discover paths with any changelist. |
| * Call @a callback_func (with @a callback_baton) each time a |
| * changelist-having path is discovered. |
| * |
| * @a local_abspath is a local WC path. |
| * |
| * If @a cancel_func is not @c NULL, invoke it passing @a cancel_baton |
| * during the recursive walk. |
| * |
| * @since New in 1.7. |
| */ |
| svn_error_t * |
| svn_wc_get_changelists(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_depth_t depth, |
| const apr_array_header_t *changelist_filter, |
| svn_changelist_receiver_t callback_func, |
| void *callback_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Crop @a local_abspath according to @a depth. |
| * |
| * Remove any item that exceeds the boundary of @a depth (relative to |
| * @a local_abspath) from revision control. Leave modified items behind |
| * (unversioned), while removing unmodified ones completely. |
| * |
| * @a depth can be svn_depth_empty, svn_depth_files or svn_depth_immediates. |
| * Excluding nodes is handled by svn_wc_exclude(). |
| * |
| * If @a local_abspath starts out with a shallower depth than @a depth, |
| * do not upgrade it to @a depth (that would not be cropping); however, do |
| * check children and crop them appropriately according to @a depth. |
| * |
| * Returns immediately with an #SVN_ERR_UNSUPPORTED_FEATURE error if @a |
| * local_abspath is not a directory, or if @a depth is not restrictive |
| * (e.g., #svn_depth_infinity). |
| * |
| * @a wc_ctx contains a tree lock, for the local path to the working copy |
| * which will be used as the root of this operation. |
| * |
| * If @a cancel_func is not @c NULL, call it with @a cancel_baton at |
| * various points to determine if the client has canceled the operation. |
| * |
| * If @a notify_func is not @c NULL, call it with @a notify_baton to |
| * report changes as they are made. |
| * |
| * @since New in 1.7 |
| */ |
| svn_error_t * |
| svn_wc_crop_tree2(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_depth_t depth, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_crop_tree2(), but uses an access baton and target. |
| * |
| * svn_wc_crop_tree() also allows #svn_depth_exclude, which is now |
| * handled via svn_wc_exclude() |
| * |
| * @a target is a basename in @a anchor or "" for @a anchor itself. |
| * |
| * @since New in 1.6 |
| * @deprecated Provided for backward compatibility with the 1.6 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_crop_tree(svn_wc_adm_access_t *anchor, |
| const char *target, |
| svn_depth_t depth, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| apr_pool_t *pool); |
| |
| /** Remove the local node for @a local_abspath from the working copy and |
| * add an excluded node placeholder in its place. |
| * |
| * This feature is only supported for unmodified nodes. An |
| * #SVN_ERR_UNSUPPORTED_FEATURE error is returned if the node can't be |
| * excluded in its current state. |
| * |
| * @a wc_ctx contains a tree lock, for the local path to the working copy |
| * which will be used as the root of this operation |
| * |
| * If @a notify_func is not @c NULL, call it with @a notify_baton to |
| * report changes as they are made. |
| * |
| * If @a cancel_func is not @c NULL, call it with @a cancel_baton at |
| * various points to determine if the client has canceled the operation. |
| * |
| * |
| * @since New in 1.7 |
| */ |
| svn_error_t * |
| svn_wc_exclude(svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_cancel_func_t cancel_func, |
| void *cancel_baton, |
| svn_wc_notify_func2_t notify_func, |
| void *notify_baton, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** @} */ |
| |
| /** |
| * Set @a kind to the #svn_node_kind_t of @a abspath. Use @a wc_ctx to access |
| * the working copy, and @a scratch_pool for all temporary allocations. |
| * |
| * If @a abspath is not under version control, set @a kind to #svn_node_none. |
| * |
| * If @a show_hidden and @a show_deleted are both @c FALSE, the kind of |
| * scheduled for delete, administrative only 'not present' and excluded |
| * nodes is reported as #svn_node_none. This is recommended as a check |
| * for 'is there a versioned file or directory here?' |
| * |
| * If @a show_deleted is FALSE, but @a show_hidden is @c TRUE then only |
| * scheduled for delete and administrative only 'not present' nodes are |
| * reported as #svn_node_none. This is recommended as check for |
| * 'Can I add a node here?' |
| * |
| * If @a show_deleted is TRUE, but @a show_hidden is FALSE, then only |
| * administrative only 'not present' nodes and excluded nodes are reported as |
| * #svn_node_none. This behavior is the behavior bescribed as 'hidden' |
| * before Subversion 1.7. |
| * |
| * If @a show_hidden and @a show_deleted are both @c TRUE all nodes are |
| * reported. |
| * |
| * @since New in 1.8. |
| */ |
| svn_error_t * |
| svn_wc_read_kind2(svn_node_kind_t *kind, |
| svn_wc_context_t *wc_ctx, |
| const char *local_abspath, |
| svn_boolean_t show_deleted, |
| svn_boolean_t show_hidden, |
| apr_pool_t *scratch_pool); |
| |
| /** Similar to svn_wc_read_kind2() but with @a show_deleted always |
| * passed as TRUE. |
| * |
| * @since New in 1.7. |
| * @deprecated Provided for backward compatibility with the 1.7 API. |
| */ |
| SVN_DEPRECATED |
| svn_error_t * |
| svn_wc_read_kind(svn_node_kind_t *kind, |
| svn_wc_context_t *wc_ctx, |
| const char *abspath, |
| svn_boolean_t show_hidden, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** @} */ |
| |
| #ifdef __cplusplus |
| } |
| #endif /* __cplusplus */ |
| |
| #endif /* SVN_WC_H */ |