svn_wc.h

Go to the documentation of this file.
00001 /**
00002  * @copyright
00003  * ====================================================================
00004  * Copyright (c) 2000-2004 CollabNet.  All rights reserved.
00005  *
00006  * This software is licensed as described in the file COPYING, which
00007  * you should have received as part of this distribution.  The terms
00008  * are also available at http://subversion.tigris.org/license-1.html.
00009  * If newer versions of this license are posted there, you may use a
00010  * newer version instead, at your option.
00011  *
00012  * This software consists of voluntary contributions made by many
00013  * individuals.  For exact contribution history, see the revision
00014  * history and logs, available at http://subversion.tigris.org/.
00015  * ====================================================================
00016  * @endcopyright
00017  *
00018  * @file svn_wc.h
00019  * @brief The Subversion Working Copy Library
00020  *
00021  * Requires:  
00022  *            - A working copy
00023  * 
00024  * Provides: 
00025  *            - Ability to manipulate working copy's versioned data.
00026  *            - Ability to manipulate working copy's administrative files.
00027  *
00028  * Used By:   
00029  *            - Clients.
00030  */
00031 
00032 #ifndef SVN_WC_H
00033 #define SVN_WC_H
00034 
00035 
00036 #include <apr.h>
00037 #include <apr_pools.h>
00038 #include <apr_tables.h>
00039 #include <apr_hash.h>
00040 
00041 #include "svn_types.h"
00042 #include "svn_string.h"
00043 #include "svn_delta.h"
00044 #include "svn_error.h"
00045 #include "svn_opt.h"
00046 #include "svn_ra.h"    /* for svn_ra_reporter_t type */
00047 
00048 #ifdef __cplusplus
00049 extern "C" {
00050 #endif /* __cplusplus */
00051 
00052 
00053 /**
00054  * Get libsvn_wc version information.
00055  *
00056  * @since New in 1.1.
00057  */
00058 const svn_version_t *svn_wc_version (void);
00059 
00060 
00061 /* Locking/Opening/Closing */
00062 
00063 /** Baton for access to a working copy administrative area.
00064  *
00065  * One day all such access will require a baton, we're not there yet.
00066  *
00067  * Access batons can be grouped into sets, by passing an existing open
00068  * baton when opening a new baton.  Given one baton in a set, other batons
00069  * may be retrieved.  This allows an entire hierarchy to be locked, and
00070  * then the set of batons can be passed around by passing a single baton.
00071  */
00072 typedef struct svn_wc_adm_access_t svn_wc_adm_access_t;
00073 
00074 
00075 /**
00076  * Return, in @a *adm_access, a pointer to a new access baton for the working
00077  * copy administrative area associated with the directory @a path.  If
00078  * @a write_lock is true the baton will include a write lock, otherwise the
00079  * baton can only be used for read access.  If @a path refers to a directory
00080  * that is already write locked then the error @c SVN_ERR_WC_LOCKED will be
00081  * returned.  The error @c SVN_ERR_WC_NOT_DIRECTORY will be returned if
00082  * @a path is not a versioned directory.
00083  *
00084  * If @a associated is an open access baton then @a adm_access will be added 
00085  * to the set containing @a associated.  @a associated can be @c NULL, in 
00086  * which case @a adm_access is the start of a new set.
00087  *
00088  * @a depth specifies how much to lock.  Zero means just the specified
00089  * directory.  Any negative value means to lock the entire working copy
00090  * directory hierarchy under @a path.  A positive value indicates the number of
00091  * levels of directories to lock -- 1 means just immediate subdirectories, 2
00092  * means immediate subdirectories and their subdirectories, etc.  All the
00093  * access batons will become part of the set containing @a adm_access.  This
00094  * is an all-or-nothing option, if it is not possible to lock all the
00095  * requested directories then an error will be returned and @a adm_access will
00096  * be invalid, with the exception that subdirectories of @a path that are
00097  * missing from the physical filesystem will not be locked and will not cause
00098  * an error.  The error @c SVN_ERR_WC_LOCKED will be returned if a
00099  * subdirectory of @a path is already write locked.
00100  *
00101  * If @a cancel_func is non-null, call it with @a cancel_baton to determine
00102  * if the client has cancelled the operation.
00103  *
00104  * @a pool will be used to allocate memory for the baton and any subsequently
00105  * cached items.  If @a adm_access has not been closed when the pool is
00106  * cleared, it will be closed automatically at that point, and removed from
00107  * its set.  A baton closed in this way will not remove physical locks from
00108  * the working copy if cleanup is required.
00109  *
00110  * The first baton in a set, with @a associated passed as @c NULL, must have 
00111  * the longest lifetime of all the batons in the set.  This implies it must be
00112  * the root of the hierarchy.
00113  *
00114  * @since New in 1.2.
00115  */
00116 svn_error_t *svn_wc_adm_open3 (svn_wc_adm_access_t **adm_access,
00117                                svn_wc_adm_access_t *associated,
00118                                const char *path,
00119                                svn_boolean_t write_lock,
00120                                int depth,
00121                                svn_cancel_func_t cancel_func,
00122                                void *cancel_baton,
00123                                apr_pool_t *pool);
00124 
00125 /**
00126  * Similar to svn_wc_adm_open3(), but without cancellation support.
00127  *
00128  * @deprecated Provided for backward compatibility with the 1.1 API.
00129  */
00130 svn_error_t *svn_wc_adm_open2 (svn_wc_adm_access_t **adm_access,
00131                                svn_wc_adm_access_t *associated,
00132                                const char *path,
00133                                svn_boolean_t write_lock,
00134                                int depth,
00135                                apr_pool_t *pool);
00136 
00137 /**
00138  * Similar to svn_wc_adm_open2(), but with @a tree_lock instead of
00139  * @a depth.  @a depth is set to -1 if @a tree_lock is @c TRUE, else 0.
00140  *
00141  * @deprecated Provided for backward compatibility with the 1.0 API.
00142  */
00143 svn_error_t *svn_wc_adm_open (svn_wc_adm_access_t **adm_access,
00144                               svn_wc_adm_access_t *associated,
00145                               const char *path,
00146                               svn_boolean_t write_lock,
00147                               svn_boolean_t tree_lock,
00148                               apr_pool_t *pool);
00149 
00150 /**
00151  * Checks the working copy to determine the node type of @a path.  If 
00152  * @a path is a versioned directory then the behaviour is like that of
00153  * svn_wc_adm_open3(), otherwise, if @a path is a file or does not
00154  * exist, then the behaviour is like that of svn_wc_adm_open3() with
00155  * @a path replaced by the parent directory of @a path.  If @a path is
00156  * an unversioned directory, the behaviour is also like that of
00157  * svn_wc_adm_open3() on the parent, except that if the open fails,
00158  * then the returned SVN_ERR_WC_NOT_DIRECTORY error refers to @a path,
00159  * not to @a path's parent.
00160  *
00161  * @since New in 1.2.
00162  */
00163 svn_error_t *svn_wc_adm_probe_open3 (svn_wc_adm_access_t **adm_access,
00164                                      svn_wc_adm_access_t *associated,
00165                                      const char *path,
00166                                      svn_boolean_t write_lock,
00167                                      int depth,
00168                                      svn_cancel_func_t cancel_func,
00169                                      void *cancel_baton,
00170                                      apr_pool_t *pool);
00171 
00172 /**
00173  * Similar to svn_wc_adm_probe_open3() without the cancel
00174  * functionality.
00175  *
00176  * @deprecated Provided for backward compatibility with the 1.1 API.
00177  */
00178 svn_error_t *svn_wc_adm_probe_open2 (svn_wc_adm_access_t **adm_access,
00179                                      svn_wc_adm_access_t *associated,
00180                                      const char *path,
00181                                      svn_boolean_t write_lock,
00182                                      int depth,
00183                                      apr_pool_t *pool);
00184 
00185 /**
00186  * Similar to svn_wc_adm_probe_open2(), but with @a tree_lock instead of
00187  * @a depth.  @a depth is set to -1 if @a tree_lock is @c TRUE, else 0.
00188  *
00189  * @deprecated Provided for backward compatibility with the 1.0 API.
00190  */
00191 svn_error_t *svn_wc_adm_probe_open (svn_wc_adm_access_t **adm_access,
00192                                     svn_wc_adm_access_t *associated,
00193                                     const char *path,
00194                                     svn_boolean_t write_lock,
00195                                     svn_boolean_t tree_lock,
00196                                     apr_pool_t *pool);
00197 
00198 /**
00199  * Open access batons for @a path and return in @a *anchor_access and
00200  * @a *target the anchor and target required to drive an editor.  Return
00201  * in @a *target_access the access baton for the target, which may be the
00202  * same as @a *anchor_access.  All the access batons will be in the
00203  * @a *anchor_access set.
00204  *
00205  * @a depth determines the depth used when opening @a path if @a path is a
00206  * versioned directory, @a depth is ignored otherwise.  If @a write_lock is
00207  * @c TRUE the access batons will hold write locks.
00208  *
00209  * If @a cancel_func is non-null, call it with @a cancel_baton to determine
00210  * if the client has cancelled the operation.
00211  *
00212  * This function is essentially a combination of svn_wc_adm_open3() and
00213  * svn_wc_get_actual_target(), with the emphasis on reducing physical IO.
00214  *
00215  * @since New in 1.2.
00216  */
00217 svn_error_t *
00218 svn_wc_adm_open_anchor (svn_wc_adm_access_t **anchor_access,
00219                         svn_wc_adm_access_t **target_access,
00220                         const char **target,
00221                         const char *path,
00222                         svn_boolean_t write_lock,
00223                         int depth,
00224                         svn_cancel_func_t cancel_func,
00225                         void *cancel_baton,
00226                         apr_pool_t *pool);
00227 
00228 /** Return, in @a *adm_access, a pointer to an existing access baton associated
00229  * with @a path.  @a path must be a directory that is locked as part of the 
00230  * set containing the @a associated access baton.
00231  *
00232  * If the requested access baton is marked as missing in, or is simply
00233  * absent from, @a associated, return SVN_ERR_WC_NOT_LOCKED.
00234  *
00235  * @a pool is used only for local processing, it is not used for the batons.
00236  */
00237 svn_error_t *svn_wc_adm_retrieve (svn_wc_adm_access_t **adm_access,
00238                                   svn_wc_adm_access_t *associated,
00239                                   const char *path,
00240                                   apr_pool_t *pool);
00241 
00242 /** Checks the working copy to determine the node type of @a path.  If 
00243  * @a path is a versioned directory then the behaviour is like that of
00244  * svn_wc_adm_retrieve(), otherwise, if @a path is a file, an unversioned
00245  * directory, or does not exist, then the behaviour is like that of
00246  * svn_wc_adm_retrieve() with @a path replaced by the parent directory of
00247  * @a path.
00248  */
00249 svn_error_t *svn_wc_adm_probe_retrieve (svn_wc_adm_access_t **adm_access,
00250                                         svn_wc_adm_access_t *associated,
00251                                         const char *path,
00252                                         apr_pool_t *pool);
00253 
00254 /**
00255  * Try various ways to obtain an access baton for @a path.
00256  *
00257  * First, try to obtain @a *adm_access via svn_wc_adm_probe_retrieve(),
00258  * but if this fails because @a associated can't give a baton for
00259  * @a path or @a path's parent, then try svn_wc_adm_probe_open3(),
00260  * this time passing @a write_lock and @a depth.  If there is
00261  * still no access because @a path is not a versioned directory, then
00262  * just set @a *adm_access to null and return success.  But if it is
00263  * because @a path is locked, then return the error @c SVN_ERR_WC_LOCKED,
00264  * and the effect on @a *adm_access is undefined.  (Or if the attempt
00265  * fails for any other reason, return the corresponding error, and the
00266  * effect on @a *adm_access is also undefined.)
00267  *
00268  * If svn_wc_adm_probe_open3() succeeds, then add @a *adm_access to
00269  * @a associated.
00270  *
00271  * If @a cancel_func is non-null, call it with @a cancel_baton to determine
00272  * if the client has cancelled the operation.
00273  *
00274  * Use @a pool only for local processing, not to allocate @a *adm_access.
00275  *
00276  * @since New in 1.2.
00277  */
00278 svn_error_t *svn_wc_adm_probe_try3 (svn_wc_adm_access_t **adm_access,
00279                                     svn_wc_adm_access_t *associated,
00280                                     const char *path,
00281                                     svn_boolean_t write_lock,
00282                                     int depth,
00283                                     svn_cancel_func_t cancel_func,
00284                                     void *cancel_baton,
00285                                     apr_pool_t *pool);
00286 
00287 /**
00288  * Similar to svn_wc_adm_probe_try3() without the cancel
00289  * functionality.
00290  *
00291  * @deprecated Provided for backward compatibility with the 1.1 API.
00292  */
00293 svn_error_t *svn_wc_adm_probe_try2 (svn_wc_adm_access_t **adm_access,
00294                                     svn_wc_adm_access_t *associated,
00295                                     const char *path,
00296                                     svn_boolean_t write_lock,
00297                                     int depth,
00298                                     apr_pool_t *pool);
00299 
00300 /**
00301  * Similar to svn_wc_adm_probe_try2(), but with @a tree_lock instead of
00302  * @a depth.  @a depth is set to -1 if @a tree_lock is @c TRUE, else 0.
00303  *
00304  * @deprecated Provided for backward compatibility with the 1.0 API.
00305  */
00306 svn_error_t *svn_wc_adm_probe_try (svn_wc_adm_access_t **adm_access,
00307                                    svn_wc_adm_access_t *associated,
00308                                    const char *path,
00309                                    svn_boolean_t write_lock,
00310                                    svn_boolean_t tree_lock,
00311                                    apr_pool_t *pool);
00312 
00313 
00314 /** Give up the access baton @a adm_access, and its lock if any. This will
00315  * recursively close any batons in the same set that are direct
00316  * subdirectories of @a adm_access.  Any physical locks will be removed from
00317  * the working copy.  Lock removal is unconditional, there is no check to
00318  * determine if cleanup is required.
00319  */
00320 svn_error_t *svn_wc_adm_close (svn_wc_adm_access_t *adm_access);
00321 
00322 /** Return the path used to open the access baton @a adm_access */
00323 const char *svn_wc_adm_access_path (svn_wc_adm_access_t *adm_access);
00324 
00325 /** Return the pool used by access baton @a adm_access */
00326 apr_pool_t *svn_wc_adm_access_pool (svn_wc_adm_access_t *adm_access);
00327 
00328 /** Return @c TRUE is the access baton @a adm_access has a write lock,
00329  * @c FALSE otherwise. Compared to svn_wc_locked() this is a cheap, fast
00330  * function that doesn't access the filesystem.
00331  */
00332 svn_boolean_t svn_wc_adm_locked(svn_wc_adm_access_t *adm_access);
00333 
00334 /** Set @a *locked to non-zero if @a path is locked, else set it to zero. */
00335 svn_error_t *svn_wc_locked (svn_boolean_t *locked, 
00336                             const char *path,
00337                             apr_pool_t *pool);
00338 
00339 
00340 /**
00341  * Return @c TRUE if @a name is the name of the WC administrative
00342  * directory.  Use @a pool for any temporary allocations.
00343  *
00344  * For compatibility, the default name (.svn) will always be treated
00345  * as an admin dir name, even if the working copy is actually using an
00346  * alternative name.
00347  *
00348  * @since New in 1.3.
00349  */
00350 svn_boolean_t svn_wc_is_adm_dir (const char *name, apr_pool_t *pool);
00351 
00352 
00353 /**
00354  * Return the name of the administrative directory.
00355  * Use @a pool for any temporary allocations.
00356  *
00357  * The returned pointer will refer to either a statically allocated
00358  * string, or to a string allocated in @a pool.
00359  *
00360  * @since New in 1.3.
00361  */
00362 const char *svn_wc_get_adm_dir (apr_pool_t *pool);
00363 
00364 
00365 /**
00366  * Use @a name for the administrative directory in the working copy.
00367  * Use @a pool for any temporary allocations.
00368  *
00369  * The list of valid names is limited.  Currently only ".svn" (the
00370  * default) and "_svn" are allowed.
00371  *
00372  * @note This function changes global (per-process) state and must be
00373  * called in a single-threaded context during the initialization of a
00374  * Subversion client.
00375  *
00376  * @since New in 1.3.
00377  */
00378 svn_error_t *svn_wc_set_adm_dir (const char *name, apr_pool_t *pool);
00379 
00380 
00381 
00382 /** Traversal information is information gathered by a working copy
00383  * crawl or update.  For example, the before and after values of the
00384  * svn:externals property are important after an update, and since
00385  * we're traversing the working tree anyway (a complete traversal
00386  * during the initial crawl, and a traversal of changed paths during
00387  * the checkout/update/switch), it makes sense to gather the
00388  * property's values then instead of making a second pass.
00389  */
00390 typedef struct svn_wc_traversal_info_t svn_wc_traversal_info_t;
00391 
00392 
00393 /** Return a new, empty traversal info object, allocated in @a pool. */
00394 svn_wc_traversal_info_t *svn_wc_init_traversal_info (apr_pool_t *pool);
00395 
00396 
00397 /** Set @a *externals_old and @a *externals_new to hash tables representing
00398  * changes to values of the svn:externals property on directories
00399  * traversed by @a traversal_info.
00400  *
00401  * @a traversal_info is obtained from svn_wc_init_traversal_info(), but is
00402  * only useful after it has been passed through another function, such
00403  * as svn_wc_crawl_revisions(), svn_wc_get_update_editor(),
00404  * svn_wc_get_switch_editor(), etc.
00405  *
00406  * Each hash maps <tt>const char *</tt> directory names onto 
00407  * <tt>const char *</tt> values of the externals property for that directory.  
00408  * The dir names are full paths -- that is, anchor plus target, not target 
00409  * alone. The values are not parsed, they are simply copied raw, and are
00410  * never null: directories that acquired or lost the property are
00411  * simply omitted from the appropriate table.  Directories whose value
00412  * of the property did not change show the same value in each hash.
00413  *
00414  * The hashes, keys, and values have the same lifetime as @a traversal_info.
00415  */
00416 void svn_wc_edited_externals (apr_hash_t **externals_old,
00417                               apr_hash_t **externals_new,
00418                               svn_wc_traversal_info_t *traversal_info);
00419 
00420 
00421 /** One external item.  This usually represents one line from an
00422  * svn:externals description but with the path and URL
00423  * canonicalized.
00424  */
00425 typedef struct svn_wc_external_item_t
00426 {
00427   /** The name of the subdirectory into which this external should be
00428       checked out.  This is relative to the parent directory that
00429       holds this external item.  (Note that these structs are often
00430       stored in hash tables with the target dirs as keys, so this
00431       field will often be redundant.) */
00432   const char *target_dir;
00433 
00434   /** Where to check out from. */
00435   const char *url;
00436 
00437   /** What revision to check out.  The only valid kinds for this are
00438       svn_opt_revision_number, svn_opt_revision_date, and
00439       svn_opt_revision_head. */
00440   svn_opt_revision_t revision;
00441 
00442 } svn_wc_external_item_t;
00443 
00444 
00445 /**
00446  * Return a duplicate of @a item, allocated in @a pool.  No part of the new
00447  * item will be shared with @a item.
00448  *
00449  * @since New in 1.3.
00450  */
00451 svn_wc_external_item_t *
00452 svn_wc_external_item_dup (const svn_wc_external_item_t *item,
00453                           apr_pool_t *pool);
00454 
00455 
00456 /**
00457  * If @a externals_p is non-null, set @a *externals_p to an array of
00458  * @c svn_wc_external_item_t * objects based on @a desc.
00459  *
00460  * If the format of @a desc is invalid, don't touch @a *externals_p and
00461  * return @c SVN_ERR_CLIENT_INVALID_EXTERNALS_DESCRIPTION.  Thus, if
00462  * you just want to check the validity of an externals description,
00463  * and don't care about the parsed result, pass null for @a externals_p.
00464  *
00465  * The format of @a desc is the same as for values of the directory
00466  * property @c SVN_PROP_EXTERNALS, which see.
00467  *
00468  * Allocate the table, keys, and values in @a pool.
00469  *
00470  * Use @a parent_directory only in constructing error strings.
00471  *
00472  * @since New in 1.1.
00473  */
00474 svn_error_t *
00475 svn_wc_parse_externals_description2 (apr_array_header_t **externals_p,
00476                                      const char *parent_directory,
00477                                      const char *desc,
00478                                      apr_pool_t *pool);
00479 
00480 
00481 /**
00482  * Similar to svn_wc_parse_externals_description2(), but returns the
00483  * parsed externals in a hash instead of an array.  This function
00484  * should not be used, as storing the externals in a hash causes their
00485  * order of evaluation to be not easily identifiable.
00486  *
00487  * @deprecated Provided for backward compatibility with the 1.0 API.
00488  */
00489 svn_error_t *
00490 svn_wc_parse_externals_description (apr_hash_t **externals_p,
00491                                     const char *parent_directory,
00492                                     const char *desc,
00493                                     apr_pool_t *pool);
00494 
00495 
00496 
00497 /* Notification/callback handling. */
00498 
00499 /**
00500  * @defgroup svn_wc_notifications notification callback handling
00501  * @{
00502  *
00503  * In many cases, the WC library will scan a working copy and make
00504  * changes. The caller usually wants to know when each of these changes
00505  * has been made, so that it can display some kind of notification to
00506  * the user.
00507  *
00508  * These notifications have a standard callback function type, which
00509  * takes the path of the file that was affected, and a caller-
00510  * supplied baton.
00511  *
00512  * Note that the callback is a 'void' return -- this is a simple
00513  * reporting mechanism, rather than an opportunity for the caller to
00514  * alter the operation of the WC library.
00515  *
00516  * Note also that some of the actions are used across several
00517  * different Subversion commands.  For example, the update actions are
00518  * also used for checkouts, switches, and merges.
00519  */
00520 
00521 /** The type of action occurring. */
00522 typedef enum svn_wc_notify_action_t
00523 {
00524   /** Adding a path to revision control. */
00525   svn_wc_notify_add = 0,
00526 
00527   /** Copying a versioned path. */
00528   svn_wc_notify_copy,
00529   
00530   /** Deleting a versioned path. */
00531   svn_wc_notify_delete,
00532 
00533   /** Restoring a missing path from the pristine text-base. */
00534   svn_wc_notify_restore,
00535   
00536   /** Reverting a modified path. */
00537   svn_wc_notify_revert,
00538 
00539   /** A revert operation has failed. */
00540   svn_wc_notify_failed_revert,
00541 
00542   /** Resolving a conflict. */
00543   svn_wc_notify_resolved,
00544 
00545   /** Skipping a path. */
00546   svn_wc_notify_skip,
00547 
00548   /** Got a delete in an update. */
00549   svn_wc_notify_update_delete,
00550 
00551   /** Got an add in an update. */
00552   svn_wc_notify_update_add,
00553 
00554   /** Got any other action in an update. */
00555   svn_wc_notify_update_update,
00556 
00557   /** The last notification in an update (including updates of externals). */
00558   svn_wc_notify_update_completed,
00559 
00560   /** Updating an external module. */
00561   svn_wc_notify_update_external,
00562 
00563   /** The last notification in a status (including status on externals). */
00564   svn_wc_notify_status_completed,
00565 
00566   /** Running status on an external module. */
00567   svn_wc_notify_status_external,
00568 
00569   /** Committing a modification. */
00570   svn_wc_notify_commit_modified,
00571   
00572   /** Committing an addition. */
00573   svn_wc_notify_commit_added,
00574 
00575   /** Committing a deletion. */
00576   svn_wc_notify_commit_deleted,
00577 
00578   /** Committing a replacement. */
00579   svn_wc_notify_commit_replaced,
00580 
00581   /** Transmitting post-fix text-delta data for a file. */
00582   svn_wc_notify_commit_postfix_txdelta,
00583 
00584   /** Processed a single revision's blame. */
00585   svn_wc_notify_blame_revision,
00586 
00587   /** Locking a path. @since New in 1.2. */
00588   svn_wc_notify_locked,
00589 
00590   /** Unlocking a path. @since New in 1.2. */
00591   svn_wc_notify_unlocked,
00592 
00593   /** Failed to lock a path. @since New in 1.2. */
00594   svn_wc_notify_failed_lock,
00595 
00596   /** Failed to unlock a path. @since New in 1.2. */
00597   svn_wc_notify_failed_unlock
00598 } svn_wc_notify_action_t;
00599 
00600 
00601 /** The type of notification that is occurring. */
00602 typedef enum svn_wc_notify_state_t
00603 {
00604   svn_wc_notify_state_inapplicable = 0,
00605 
00606   /** Notifier doesn't know or isn't saying. */
00607   svn_wc_notify_state_unknown,
00608 
00609   /** The state did not change. */
00610   svn_wc_notify_state_unchanged,
00611 
00612   /** The item wasn't present. */
00613   svn_wc_notify_state_missing,
00614 
00615   /** An unversioned item obstructed work. */
00616   svn_wc_notify_state_obstructed,
00617 
00618   /** Pristine state was modified. */
00619   svn_wc_notify_state_changed,
00620 
00621   /** Modified state had mods merged in. */
00622   svn_wc_notify_state_merged,
00623 
00624   /** Modified state got conflicting mods. */
00625   svn_wc_notify_state_conflicted
00626 
00627 } svn_wc_notify_state_t;
00628 
00629 /**
00630  * What happened to a lock during an operation.
00631  *
00632  * @since New in 1.2.
00633  */
00634 typedef enum svn_wc_notify_lock_state_t {
00635   svn_wc_notify_lock_state_inapplicable = 0,
00636   svn_wc_notify_lock_state_unknown,
00637   /** The lock wasn't changed. */
00638   svn_wc_notify_lock_state_unchanged,
00639   /** The item was locked. */
00640   svn_wc_notify_lock_state_locked,
00641   /** The item was unlocked. */
00642   svn_wc_notify_lock_state_unlocked
00643 } svn_wc_notify_lock_state_t;
00644 
00645 /**
00646  * Structure used in the @c svn_wc_notify_func2_t function.
00647  *
00648  * @c path is either absolute or relative to the current working directory
00649  * (i.e., not relative to an anchor).  @c action describes what happened
00650  * to @c path.
00651  *
00652  * @c kind, @c content_state, @c prop_state and @c lock_state are from
00653  * after @c action, not before.  @c lock_state reflects the addition
00654  * or removal of a lock token in the working copy.
00655  *
00656  * If @c mime_type is non-null, it indicates the mime-type of @c path.
00657  * It is always @c NULL for directories.
00658  *
00659  * If @c action is @c svn_wc_notify_update_completed, @c revision is the
00660  * target revision of the update, or @c SVN_INVALID_REVNUM if not
00661  * available.  If @c action is @c svn_wc_notify_blame_revision, @c
00662  * revision is the processed revision.  In all other cases, @c
00663  * revision is @c SVN_INVALID_REVNUM.
00664  *
00665  * For an @c action of svn_wc_notify_locked, @c lock is the lock
00666  * structure received from the repository.  For other actions, it is
00667  * @c NULL.
00668  *
00669  * @c err is @c NULL, except when @c action is @c
00670  * svn_wc_notify_failed_lock or @c svn_wc_notify_failed_unlock, in
00671  * which case it points to an error describing the reason for the failure.
00672  *
00673  * Note that if @c action is @c svn_wc_notify_update, then @c path has 
00674  * already been installed, so it is legitimate for an implementation of
00675  * @c svn_wc_notify_func2_t to examine @c path in the working copy.
00676  *
00677  * @note The purpose of the @c kind, @c mime_type, @c content_state, and
00678  * @c prop_state fields is to provide "for free" information that an
00679  * implementation is likely to want, and which it would otherwise be
00680  * forced to deduce via expensive operations such as reading entries
00681  * and properties.  However, if the caller does not have this
00682  * information, it will simply pass the corresponding `*_unknown'
00683  * values, and it is up to the implementation how to handle that
00684  * (i.e., whether to attempt deduction, or just to punt and
00685  * give a less informative notification).
00686  *
00687  * @note Callers of notification functions should use svn_wc_create_notify()
00688  * to create structures of this type to allow for extensibility.
00689  *
00690  * @since New in 1.2.
00691  */
00692 typedef struct svn_wc_notify_t {
00693   const char *path;
00694   svn_wc_notify_action_t action;
00695   svn_node_kind_t kind;
00696   const char *mime_type;
00697   const svn_lock_t *lock;
00698   svn_error_t *err;
00699   svn_wc_notify_state_t content_state;
00700   svn_wc_notify_state_t prop_state;
00701   svn_wc_notify_lock_state_t lock_state;
00702   svn_revnum_t revision;
00703   /* NOTE: Add new fields at the end to preserve binary compatibility.
00704      Also, if you add fields here, you have to update svn_wc_create_notify
00705      and svn_wc_dup_notify. */
00706 } svn_wc_notify_t;
00707 
00708 /**
00709  * Allocate an @c svn_wc_notify_t structure in @a pool, initialize and return
00710  * it.
00711  *
00712  * Set the @c path field of the created struct to @a path, and @c action to
00713  * @a action.  Set all other fields to their @c _unknown, @c NULL or
00714  * invalid value, respectively.
00715  *
00716  * @since New in 1.2.
00717  */
00718 svn_wc_notify_t *
00719 svn_wc_create_notify (const char *path, svn_wc_notify_action_t action,
00720                       apr_pool_t *pool);
00721 
00722 /**
00723  * Return a deep copy of @a notify, allocated in @a pool.
00724  *
00725  * @since New in 1.2.
00726  */
00727 svn_wc_notify_t *
00728 svn_wc_dup_notify (const svn_wc_notify_t *notify, apr_pool_t *pool);
00729 
00730 /**
00731  * Notify the world that @a notify->action has happened to @a notify->path.
00732  *
00733  * Recommendation: callers of @c svn_wc_notify_func2_t should avoid
00734  * invoking it multiple times on the same path within a given
00735  * operation, and implementations should not bother checking for such
00736  * duplicate calls.  For example, in an update, the caller should not
00737  * invoke the notify func on receiving a prop change and then again
00738  * on receiving a text change.  Instead, wait until all changes have
00739  * been received, and then invoke the notify func once (from within
00740  * an @c svn_delta_editor_t's close_file(), for example), passing 
00741  * the appropriate @a notify->content_state and @a notify->prop_state flags.
00742  *
00743  * @since New in 1.2.
00744  */
00745 typedef void (*svn_wc_notify_func2_t) (void *baton,
00746                                        const svn_wc_notify_t *notify,
00747                                        apr_pool_t *pool);
00748 
00749 /**
00750  * Similar to @c svn_wc_notify_func2_t, but takes the information as arguments
00751  * instead of struct fields.
00752  *
00753  * @deprecated Provided for backward compatibility with the 1.1 API.
00754  */
00755 typedef void (*svn_wc_notify_func_t) (void *baton,
00756                                       const char *path,
00757                                       svn_wc_notify_action_t action,
00758                                       svn_node_kind_t kind,
00759                                       const char *mime_type,
00760                                       svn_wc_notify_state_t content_state,
00761                                       svn_wc_notify_state_t prop_state,
00762                                       svn_revnum_t revision);
00763 
00764 /** @} */
00765 
00766 
00767 
00768 /**
00769  * A callback vtable invoked by our diff-editors, as they receive
00770  * diffs from the server.  'svn diff' and 'svn merge' both implement
00771  * their own versions of this table.
00772  *
00773  * @since New in 1.2.
00774  */
00775 typedef struct svn_wc_diff_callbacks2_t
00776 {
00777   /** A file @a path has changed.  If @a tmpfile2 is non-null, the
00778    * contents have changed and those changes can be seen by comparing
00779    * @a tmpfile1 and @a tmpfile2, which represent @a rev1 and @a rev2 of 
00780    * the file, respectively.
00781    *
00782    * If known, the @c svn:mime-type value of each file is passed into
00783    * @a mimetype1 and @a mimetype2;  either or both of the values can
00784    * be NULL.  The implementor can use this information to decide if
00785    * (or how) to generate differences.
00786    *
00787    * @a propchanges is an array of (@c svn_prop_t) structures. If it has
00788    * any elements, the original list of properties is provided in
00789    * @a originalprops, which is a hash of @c svn_string_t values, keyed on the
00790    * property name.
00791    * 
00792    * @a adm_access will be an access baton for the directory containing 
00793    * @a path, or @c NULL if the diff editor is not using access batons.
00794    *
00795    * If @a contentstate is non-null, set @a *contentstate to the state of
00796    * the file contents after the operation has been performed.  The same
00797    * applies for @a propstate regarding the property changes.  (In
00798    * practice, this is only useful with merge, not diff; diff callbacks
00799    * will probably set @a *contentstate and @a *propstate to
00800    * @c svn_wc_notify_state_unknown, since they do not change the state and
00801    * therefore do not bother to know the state after the operation.)
00802    */
00803   svn_error_t *(*file_changed) (svn_wc_adm_access_t *adm_access,
00804                                 svn_wc_notify_state_t *contentstate,
00805                                 svn_wc_notify_state_t *propstate,
00806                                 const char *path,
00807                                 const char *tmpfile1,
00808                                 const char *tmpfile2,
00809                                 svn_revnum_t rev1,
00810                                 svn_revnum_t rev2,
00811                                 const char *mimetype1,
00812                                 const char *mimetype2,
00813                                 const apr_array_header_t *propchanges,
00814                                 apr_hash_t *originalprops,
00815                                 void *diff_baton);
00816 
00817   /** A file @a path was added.  The contents can be seen by comparing
00818    * @a tmpfile1 and @a tmpfile2, which represent @a rev1 and @a rev2
00819    * of the file, respectively.  (If either file is empty, the rev
00820    * will be 0.)
00821    *
00822    * If known, the @c svn:mime-type value of each file is passed into
00823    * @a mimetype1 and @a mimetype2;  either or both of the values can
00824    * be NULL.  The implementor can use this information to decide if
00825    * (or how) to generate differences.
00826    *
00827    * @a propchanges is an array of (@c svn_prop_t) structures.  If it contains
00828    * any elements, the original list of properties is provided in
00829    * @a originalprops, which is a hash of @c svn_string_t values, keyed on the
00830    * property name.
00831    * 
00832    * @a adm_access will be an access baton for the directory containing 
00833    * @a path, or @c NULL if the diff editor is not using access batons.
00834    *
00835    * If @a contentstate is non-null, set @a *contentstate to the state of the
00836    * file contents after the operation has been performed.  The same
00837    * applies for @a propstate regarding the property changes.  (In practice,
00838    * this is only useful with merge, not diff; diff callbacks will
00839    * probably set @a *contentstate and *propstate to
00840    * @c svn_wc_notify_state_unknown, since they do not change the state
00841    * and therefore do not bother to know the state after the operation.)
00842    *
00843    */
00844   svn_error_t *(*file_added) (svn_wc_adm_access_t *adm_access,
00845                               svn_wc_notify_state_t *contentstate,
00846                               svn_wc_notify_state_t *propstate,
00847                               const char *path,
00848                               const char *tmpfile1,
00849                               const char *tmpfile2,
00850                               svn_revnum_t rev1,
00851                               svn_revnum_t rev2,
00852                               const char *mimetype1,
00853                               const char *mimetype2,
00854                               const apr_array_header_t *propchanges,
00855                               apr_hash_t *originalprops,
00856                               void *diff_baton);
00857   
00858   /** A file @a path was deleted.  The [loss of] contents can be seen by
00859    * comparing @a tmpfile1 and @a tmpfile2.  @a originalprops provides
00860    * the properties of the file.
00861    *
00862    * If known, the @c svn:mime-type value of each file is passed into
00863    * @a mimetype1 and @a mimetype2;  either or both of the values can
00864    * be NULL.  The implementor can use this information to decide if
00865    * (or how) to generate differences.
00866    *
00867    * @a adm_access will be an access baton for the directory containing 
00868    * @a path, or @c NULL if the diff editor is not using access batons.
00869    *
00870    * If @a state is non-null, set @a *state to the state of the item
00871    * after the delete operation has been performed.  (In practice,
00872    * this is only useful with merge, not diff; diff callbacks will
00873    * probably set @a *state to @c svn_wc_notify_state_unknown, since 
00874    * they do not change the state and therefore do not bother to know 
00875    * the state after the operation.)
00876    */
00877   svn_error_t *(*file_deleted) (svn_wc_adm_access_t *adm_access,
00878                                 svn_wc_notify_state_t *state,
00879                                 const char *path,
00880                                 const char *tmpfile1,
00881                                 const char *tmpfile2,
00882                                 const char *mimetype1,
00883                                 const char *mimetype2,
00884                                 apr_hash_t *originalprops,
00885                                 void *diff_baton);
00886   
00887   /** A directory @a path was added.  @a rev is the revision that the
00888    * directory came from.
00889    *
00890    * @a adm_access will be an access baton for the directory containing 
00891    * @a path, or @c NULL if the diff editor is not using access batons.
00892    */
00893   svn_error_t *(*dir_added) (svn_wc_adm_access_t *adm_access,
00894                              svn_wc_notify_state_t *state,
00895                              const char *path,
00896                              svn_revnum_t rev,
00897                              void *diff_baton);
00898   
00899   /** A directory @a path was deleted.
00900    *
00901    * @a adm_access will be an access baton for the directory containing 
00902    * @a path, or @c NULL if the diff editor is not using access batons.
00903    *
00904    * If @a state is non-null, set @a *state to the state of the item
00905    * after the delete operation has been performed.  (In practice,
00906    * this is only useful with merge, not diff; diff callbacks will
00907    * probably set @a *state to @c svn_wc_notify_state_unknown, since 
00908    * they do not change the state and therefore do not bother to know 
00909    * the state after the operation.)
00910    */
00911   svn_error_t *(*dir_deleted) (svn_wc_adm_access_t *adm_access,
00912                                svn_wc_notify_state_t *state,
00913                                const char *path,
00914                                void *diff_baton);
00915   
00916   /** A list of property changes (@a propchanges) was applied to the
00917    * directory @a path.
00918    *
00919    * The array is a list of (@c svn_prop_t) structures. 
00920    *
00921    * The original list of properties is provided in @a original_props,
00922    * which is a hash of @c svn_string_t values, keyed on the property
00923    * name.
00924    *
00925    * @a adm_access will be an access baton for the directory containing 
00926    * @a path, or @c NULL if the diff editor is not using access batons.
00927    *
00928    * If @a state is non-null, set @a *state to the state of the properties
00929    * after the operation has been performed.  (In practice, this is only 
00930    * useful with merge, not diff; diff callbacks will probably set @a *state 
00931    * to @c svn_wc_notify_state_unknown, since they do not change the state 
00932    * and therefore do not bother to know the state after the operation.)
00933    */
00934   svn_error_t *(*dir_props_changed) (svn_wc_adm_access_t *adm_access,
00935                                      svn_wc_notify_state_t *state,
00936                                      const char *path,
00937                                      const apr_array_header_t *propchanges,
00938                                      apr_hash_t *original_props,
00939                                      void *diff_baton);
00940 
00941 } svn_wc_diff_callbacks2_t;
00942 
00943 /**
00944  * Similar to @c svn_wc_diff_callbacks2_t, but with file additions/content
00945  * changes and property changes split into different functions.
00946  *
00947  * @deprecated Provided for backward compatibility with the 1.1 API.
00948  */
00949 typedef struct svn_wc_diff_callbacks_t
00950 {
00951   /** Similar to @c file_changed in @c svn_wc_diff_callbacks2_t, but without
00952    * property change information.  @a tmpfile2 is never NULL. @a state applies
00953    * to the file contents. */
00954   svn_error_t *(*file_changed) (svn_wc_adm_access_t *adm_access,
00955                                 svn_wc_notify_state_t *state,
00956                                 const char *path,
00957                                 const char *tmpfile1,
00958                                 const char *tmpfile2,
00959                                 svn_revnum_t rev1,
00960                                 svn_revnum_t rev2,
00961                                 const char *mimetype1,
00962                                 const char *mimetype2,
00963                                 void *diff_baton);
00964 
00965   /** Similar to @c file_added in @c svn_wc_diff_callbacks2_t, but without
00966    * property change information.  @a *state applies to the file contents. */
00967   svn_error_t *(*file_added) (svn_wc_adm_access_t *adm_access,
00968                               svn_wc_notify_state_t *state,
00969                               const char *path,
00970                               const char *tmpfile1,
00971                               const char *tmpfile2,
00972                               svn_revnum_t rev1,
00973                               svn_revnum_t rev2,
00974                               const char *mimetype1,
00975                               const char *mimetype2,
00976                               void *diff_baton);
00977   
00978   /** Similar to @c file_deleted in @c svn_wc_diff_callbacks2_t, but without
00979    * the properties. */
00980   svn_error_t *(*file_deleted) (svn_wc_adm_access_t *adm_access,
00981                                 svn_wc_notify_state_t *state,
00982                                 const char *path,
00983                                 const char *tmpfile1,
00984                                 const char *tmpfile2,
00985                                 const char *mimetype1,
00986                                 const char *mimetype2,
00987                                 void *diff_baton);
00988   
00989   /** The same as @c dir_added in @c svn_wc_diff_callbacks2_t. */
00990   svn_error_t *(*dir_added) (svn_wc_adm_access_t *adm_access,
00991                              svn_wc_notify_state_t *state,
00992                              const char *path,
00993                              svn_revnum_t rev,
00994                              void *diff_baton);
00995   
00996   /** The same as @c dir_deleted in @c svn_wc_diff_callbacks2_t. */
00997   svn_error_t *(*dir_deleted) (svn_wc_adm_access_t *adm_access,
00998                                svn_wc_notify_state_t *state,
00999                                const char *path,
01000                                void *diff_baton);
01001   
01002   /** Similar to @c dir_props_changed in @c svn_wc_diff_callbacks2_t, but this
01003    * function is called for files as well as directories. */
01004   svn_error_t *(*props_changed) (svn_wc_adm_access_t *adm_access,
01005                                  svn_wc_notify_state_t *state,
01006                                  const char *path,
01007                                  const apr_array_header_t *propchanges,
01008                                  apr_hash_t *original_props,
01009                                  void *diff_baton);
01010 
01011 } svn_wc_diff_callbacks_t;
01012 
01013 
01014 /* Asking questions about a working copy. */
01015 
01016 /** Set @a *wc_format to @a path's working copy format version number if 
01017  * @a path is a valid working copy directory, else set it to 0.  
01018  * Return error @c APR_ENOENT if @a path does not exist at all.
01019  */
01020 svn_error_t *svn_wc_check_wc (const char *path,
01021                               int *wc_format,
01022                               apr_pool_t *pool);
01023 
01024 
01025 /** Set @a *has_binary_prop to @c TRUE iff @a path has been marked 
01026  * with a property indicating that it is non-text (in other words, binary).
01027  * @a adm_access is an access baton set that contains @a path.
01028  */
01029 svn_error_t *svn_wc_has_binary_prop (svn_boolean_t *has_binary_prop,
01030                                      const char *path,
01031                                      svn_wc_adm_access_t *adm_access,
01032                                      apr_pool_t *pool);
01033 
01034 
01035 /* Detecting modification. */
01036 
01037 /** Set @a *modified_p to non-zero if @a filename's text is modified
01038  * with regard to the base revision, else set @a *modified_p to zero.
01039  * @a filename is a path to the file, not just a basename. @a adm_access
01040  * must be an access baton for @a filename.
01041  *
01042  * If @a force_comparison is @c TRUE, this function will not allow
01043  * early return mechanisms that avoid actual content comparison.
01044  * Instead, if there is a text base, a full byte-by-byte comparison
01045  * will be done, and the entry checksum verified as well.  (This means
01046  * that if the text base is much longer than the working file, every
01047  * byte of the text base will still be examined.)
01048  *
01049  * If @a filename does not exist, consider it unmodified.  If it exists
01050  * but is not under revision control (not even scheduled for
01051  * addition), return the error @c SVN_ERR_ENTRY_NOT_FOUND.  */
01052 svn_error_t *svn_wc_text_modified_p (svn_boolean_t *modified_p,
01053                                      const char *filename,
01054                                      svn_boolean_t force_comparison,
01055                                      svn_wc_adm_access_t *adm_access,
01056                                      apr_pool_t *pool);
01057 
01058 
01059 /** Set @a *modified_p to non-zero if @a path's properties are modified
01060  * with regard to the base revision, else set @a modified_p to zero. 
01061  * @a adm_access must be an access baton for @a path.
01062  */
01063 svn_error_t *svn_wc_props_modified_p (svn_boolean_t *modified_p,
01064                                       const char *path,
01065                                       svn_wc_adm_access_t *adm_access,
01066                                       apr_pool_t *pool);
01067 
01068 
01069 
01070 
01071 /** Administrative subdir.
01072  *
01073  * Ideally, this would be completely private to wc internals (in fact,
01074  * it used to be that adm_subdir() in adm_files.c was the only function
01075  * who knew the adm subdir's name).  However, import wants to protect
01076  * against importing administrative subdirs, so now the name is a
01077  * matter of public record.
01078  *
01079  * @deprecated Provided for backward compatibility with the 1.2 API.
01080  */
01081 #define SVN_WC_ADM_DIR_NAME   ".svn"
01082 
01083 
01084 
01085 /* Entries and status. */
01086 
01087 /** The schedule states an entry can be in. */
01088 typedef enum svn_wc_schedule_t
01089 {
01090   /** Nothing special here */
01091   svn_wc_schedule_normal,
01092 
01093   /** Slated for addition */
01094   svn_wc_schedule_add,
01095 
01096   /** Slated for deletion */
01097   svn_wc_schedule_delete,
01098 
01099   /** Slated for replacement (delete + add) */
01100   svn_wc_schedule_replace
01101 
01102 } svn_wc_schedule_t;
01103 
01104 
01105 /** A working copy entry -- that is, revision control information about
01106  * one versioned entity.
01107  */
01108 typedef struct svn_wc_entry_t
01109 {
01110   /* IMPORTANT: If you extend this structure, check svn_wc_entry_dup() to see
01111      if you need to extend that as well. */
01112 
01113   /* General Attributes */
01114 
01115   /** entry's name */
01116   const char *name;
01117 
01118   /** base revision */
01119   svn_revnum_t revision;
01120 
01121   /** url in repository */
01122   const char *url;
01123 
01124   /** canonical repository URL or NULL if not known */
01125   const char *repos;
01126 
01127   /** repository uuid */
01128   const char *uuid;
01129 
01130   /** node kind (file, dir, ...) */
01131   svn_node_kind_t kind;
01132 
01133   /* State information */
01134 
01135   /** scheduling (add, delete, replace ...) */
01136   svn_wc_schedule_t schedule;
01137 
01138   /** in a copied state */
01139   svn_boolean_t copied;
01140 
01141   /** deleted, but parent rev lags behind */
01142   svn_boolean_t deleted;
01143 
01144   /** absent -- we know an entry of this name exists, but that's all
01145       (usually this happens because of authz restrictions)  */
01146   svn_boolean_t absent;
01147 
01148   /** for THIS_DIR entry, implies whole entries file is incomplete */
01149   svn_boolean_t incomplete;
01150 
01151   /** copyfrom location */
01152   const char *copyfrom_url;
01153 
01154   /** copyfrom revision */
01155   svn_revnum_t copyfrom_rev;
01156 
01157   /** old version of conflicted file */
01158   const char *conflict_old;
01159 
01160   /** new version of conflicted file */
01161   const char *conflict_new;
01162 
01163   /** working version of conflicted file */
01164   const char *conflict_wrk;
01165 
01166   /** property reject file */
01167   const char *prejfile;
01168 
01169   /** last up-to-date time for text contents (0 means no information available)
01170    */
01171   apr_time_t text_time;
01172 
01173   /** last up-to-date time for properties (0 means no information available) */
01174   apr_time_t prop_time;
01175 
01176   /** base64-encoded checksum for the untranslated text base file,
01177    * can be @c NULL for backwards compatibility.
01178    */
01179   const char *checksum;
01180 
01181   /* "Entry props" */
01182 
01183   /** last revision this was changed */
01184   svn_revnum_t cmt_rev;
01185 
01186   /** last date this was changed */
01187   apr_time_t cmt_date;
01188 
01189   /** last commit author of this item */
01190   const char *cmt_author;
01191 
01192   /** lock token or NULL if path not locked in this WC
01193    * @since New in 1.2.
01194    */
01195   const char *lock_token;
01196   /** lock owner, or NULL if not locked in this WC
01197    * @since New in 1.2.
01198    */
01199   const char *lock_owner;
01200   /** lock comment or NULL if not locked in this WC or no comment
01201    * @since New in 1.2.
01202    */
01203   const char *lock_comment;
01204   /** Lock creation date or 0 if not locked in this WC
01205    * @since New in 1.2.
01206    */
01207   apr_time_t lock_creation_date;
01208 
01209   /* IMPORTANT: If you extend this structure, check svn_wc_entry_dup() to see
01210      if you need to extend that as well. */
01211 } svn_wc_entry_t;
01212 
01213 
01214 /** How an entries file's owner dir is named in the entries file. */
01215 #define SVN_WC_ENTRY_THIS_DIR  ""
01216 
01217 
01218 /** Set @a *entry to an entry for @a path, allocated in the access baton 
01219  * pool.  If @a show_hidden is true, return the entry even if it's in 
01220  * 'deleted' or 'absent' state.  If @a path is not under revision
01221  * control, or if entry is hidden, not scheduled for re-addition,
01222  * and @a show_hidden is @c FALSE, then set @a *entry to @c NULL.
01223  *
01224  * @a *entry should not be modified, since doing so modifies the entries 
01225  * cache in @a adm_access without changing the entries file on disk.
01226  *
01227  * If @a path is not a directory then @a adm_access must be an access baton 
01228  * for the parent directory of @a path.  To avoid needing to know whether 
01229  * @a path is a directory or not, if @a path is a directory @a adm_access 
01230  * can still be an access baton for the parent of @a path so long as the 
01231  * access baton for @a path itself is in the same access baton set.
01232  *
01233  * Note that it is possible for @a path to be absent from disk but still
01234  * under revision control; and conversely, it is possible for @a path to
01235  * be present, but not under revision control.
01236  *
01237  * Use @a pool only for local processing.
01238  */
01239 svn_error_t *svn_wc_entry (const svn_wc_entry_t **entry,
01240                            const char *path,
01241                            svn_wc_adm_access_t *adm_access,
01242                            svn_boolean_t show_hidden,
01243                            apr_pool_t *pool);
01244 
01245 
01246 /** Parse the `entries' file for @a adm_access and return a hash @a entries, 
01247  * whose keys are (<tt>const char *</tt>) entry names and values are 
01248  * (<tt>svn_wc_entry_t *</tt>).  The hash @a entries, and its keys and
01249  * values, are allocated from the pool used to open the @a adm_access
01250  * baton (that's how the entries caching works).  @a pool is used for
01251  * transient allocations.
01252  *  
01253  * Entries that are in a 'deleted' or 'absent' state (and not
01254  * scheduled for re-addition) are not returned in the hash, unless
01255  * @a show_hidden is true.
01256  *
01257  * @par Important:
01258  * The @a entries hash is the entries cache in @a adm_access 
01259  * and so usually the hash itself, the keys and the values should be treated 
01260  * as read-only.  If any of these are modified then it is the caller's
01261  * responsibility to ensure that the entries file on disk is updated.  Treat
01262  * the hash values as type (<tt>const svn_wc_entry_t *</tt>) if you wish to 
01263  * avoid accidental modification.  Modifying the schedule member is a
01264  * particularly bad idea, as the entries writing process relies on having
01265  * access to the original schedule.  Use a duplicate entry to modify the
01266  * schedule.
01267  *
01268  * @par Important:
01269  * Only the entry structures representing files and
01270  * @c SVN_WC_ENTRY_THIS_DIR contain complete information.  The entry
01271  * structures representing subdirs have only the `kind' and `state'
01272  * fields filled in.  If you want info on a subdir, you must use this
01273  * routine to open its @a path and read the @c SVN_WC_ENTRY_THIS_DIR 
01274  * structure, or call svn_wc_entry() on its @a path.
01275  */
01276 svn_error_t *svn_wc_entries_read (apr_hash_t **entries,
01277                                   svn_wc_adm_access_t *adm_access,
01278                                   svn_boolean_t show_hidden,
01279                                   apr_pool_t *pool);
01280 
01281 
01282 /** Return a duplicate of @a entry, allocated in @a pool.  No part of the new
01283  * entry will be shared with @a entry.
01284  */
01285 svn_wc_entry_t *svn_wc_entry_dup (const svn_wc_entry_t *entry,
01286                                   apr_pool_t *pool);
01287 
01288 
01289 /** Given a @a dir_path under version control, decide if one of its
01290  * entries (@a entry) is in state of conflict; return the answers in
01291  * @a text_conflicted_p and @a prop_conflicted_p.  
01292  *
01293  * (If the entry mentions that a .rej or .prej exist, but they are
01294  * both removed, assume the conflict has been resolved by the user.)
01295  */
01296 svn_error_t *svn_wc_conflicted_p (svn_boolean_t *text_conflicted_p,
01297                                   svn_boolean_t *prop_conflicted_p,
01298                                   const char *dir_path,
01299                                   const svn_wc_entry_t *entry,
01300                                   apr_pool_t *pool);
01301 
01302 /** Set @a *url and @a *rev to the ancestor URL and revision for @a path,
01303  * allocating in @a pool.  @a adm_access must be an access baton for @a path. 
01304  *
01305  * If @a url or @a rev is null, then ignore it (just don't return the
01306  * corresponding information).
01307  */
01308 svn_error_t *svn_wc_get_ancestry (char **url,
01309                                   svn_revnum_t *rev,
01310                                   const char *path,
01311                                   svn_wc_adm_access_t *adm_access,
01312                                   apr_pool_t *pool);
01313 
01314 
01315 /** A callback vtable invoked by the generic entry-walker function. */
01316 typedef struct svn_wc_entry_callbacks_t
01317 {
01318   /** An @a entry was found at @a path. */
01319   svn_error_t *(*found_entry) (const char *path,
01320                                const svn_wc_entry_t *entry,
01321                                void *walk_baton,
01322                                apr_pool_t *pool);
01323 
01324   /* ### add more callbacks as new callers need them. */
01325 
01326 } svn_wc_entry_callbacks_t;
01327 
01328 
01329 /**
01330  * A generic entry-walker.
01331  *
01332  * Do a recursive depth-first entry-walk beginning on @a path, which can
01333  * be a file or dir.  Call callbacks in @a walk_callbacks, passing
01334  * @a walk_baton to each.  Use @a pool for looping, recursion, and to
01335  * allocate all entries returned.  @a adm_access must be an access baton
01336  * for @a path.
01337  *
01338  * If @a cancel_func is non-null, call it with @a cancel_baton to determine
01339  * if the client has cancelled the operation.
01340  *
01341  * Like our other entries interfaces, entries that are in a 'deleted'
01342  * or 'absent' state (and not scheduled for re-addition) are not
01343  * discovered, unless @a show_hidden is true.
01344  *
01345  * When a new directory is entered, @c SVN_WC_ENTRY_THIS_DIR will always
01346  * be returned first.
01347  *
01348  * @note Callers should be aware that each directory will be
01349  * returned *twice*:  first as an entry within its parent, and
01350  * subsequently as the '.' entry within itself.  The two calls can be
01351  * distinguished by looking for @c SVN_WC_ENTRY_THIS_DIR in the 'name'
01352  * field of the entry.
01353  *
01354  * @since New in 1.2.
01355  */
01356 svn_error_t *svn_wc_walk_entries2 (const char *path,
01357                                    svn_wc_adm_access_t *adm_access,
01358                                    const svn_wc_entry_callbacks_t 
01359                                                       *walk_callbacks,
01360                                    void *walk_baton,
01361                                    svn_boolean_t show_hidden,
01362                                    svn_cancel_func_t cancel_func,
01363                                    void *cancel_baton,
01364                                    apr_pool_t *pool);
01365 
01366 /**
01367  * Similar to svn_wc_walk_entries2(), but without cancellation support.
01368  *
01369  * @deprecated Provided for backward compatibility with the 1.0 API.
01370  */
01371 svn_error_t *svn_wc_walk_entries (const char *path,
01372                                   svn_wc_adm_access_t *adm_access,
01373                                   const svn_wc_entry_callbacks_t 
01374                                                      *walk_callbacks,
01375                                   void *walk_baton,
01376                                   svn_boolean_t show_hidden,
01377                                   apr_pool_t *pool);
01378 
01379 
01380 /** Mark missing @a path as 'deleted' in its @a parent's list of entries.
01381  *
01382  * Return @c SVN_ERR_WC_PATH_FOUND if @a path isn't actually missing.
01383  */
01384 svn_error_t *svn_wc_mark_missing_deleted (const char *path,
01385                                           svn_wc_adm_access_t *parent,
01386                                           apr_pool_t *pool);
01387                        
01388 
01389 
01390 /** Ensure that an administrative area exists for @a path, so that @a
01391  * path is a working copy subdir based on @a url at @a revision, and
01392  * with repository UUID @a uuid and repository root URL @a repos.
01393  * @a uuid and @a repos may be @c NULL.  If non-@c NULL, @a repos must be a
01394  * prefix of @a url.
01395  *
01396  * If the administrative area does not exist, then create it and
01397  * initialize it to an unlocked state.
01398  *
01399  * If the administrative area already exists then the given @a url
01400  * must match the URL in the administrative area or an error will be
01401  * returned. The given @a revision must also match except for the
01402  * special case of adding a directory that has a name matching one
01403  * scheduled for deletion, in which case @a revision must be zero.
01404  *
01405  * Do not ensure existence of @a path itself; if @a path does not
01406  * exist, return error.
01407  *
01408  * @since New in 1.3.
01409  */
01410 svn_error_t *svn_wc_ensure_adm2 (const char *path,
01411                                  const char *uuid,
01412                                  const char *url,
01413                                  const char *repos,
01414                                  svn_revnum_t revision,
01415                                  apr_pool_t *pool);
01416 
01417 
01418 /** Similar to svn_wc_ensure_adm2(), but with @a repos set to @c NULL.
01419  *
01420  * @deprecated Provided for backwards compatibility with the 1.2 API.
01421  */
01422 svn_error_t *svn_wc_ensure_adm (const char *path,
01423                                 const char *uuid,
01424                                 const char *url,
01425                                 svn_revnum_t revision,
01426                                 apr_pool_t *pool);
01427 
01428 
01429 /** Set the repository root URL of @a path to @a repos, if possible.
01430  *
01431  * @a adm_access must contain @a path and be write-locked, if @a path
01432  * is versioned.  Return no error if path is missing or unversioned.
01433  * Use @a pool for temporary allocations.
01434  *
01435  * @note In some circumstances, the repository root can't be set
01436  * without making the working copy corrupt.  In such cases, this
01437  * function just returns no error, without modifying the @a path entry.
01438  *
01439  * @note This function exists to make it possible to try to set the repository
01440  * root in old working copies; new working copies normally get this set at
01441  * creation time.
01442  * 
01443  * @since New in 1.3.
01444  */
01445 svn_error_t *
01446 svn_wc_maybe_set_repos_root (svn_wc_adm_access_t *adm_access,
01447                              const char *path, const char *repos,
01448                              apr_pool_t *pool);
01449 
01450 
01451 /** 
01452  * @defgroup svn_wc_status working copy status.
01453  * @{
01454  *
01455  * We have two functions for getting working copy status: one function
01456  * for getting the status of exactly one thing, and another for
01457  * getting the statuses of (potentially) multiple things.
01458  * 
01459  * The WebDAV concept of "depth" may be useful in understanding the
01460  * motivation behind this.  Suppose we're getting the status of
01461  * directory D.  The three depth levels would mean
01462  * 
01463  *    depth 0:         D itself (just the named directory)
01464  *    depth 1:         D and its immediate children (D + its entries)
01465  *    depth Infinity:  D and all its descendants (full recursion)
01466  * 
01467  * To offer all three levels, we could have one unified function,
01468  * taking a `depth' parameter.  Unfortunately, because this function
01469  * would have to handle multiple return values as well as the single
01470  * return value case, getting the status of just one entity would
01471  * become cumbersome: you'd have to roll through a hash to find one
01472  * lone status.
01473  * 
01474  * So we have svn_wc_status() for depth 0, and 
01475  * svn_wc_get_status_editor() for depths 1 and 2, since the latter
01476  * two involve multiple return values.
01477  *
01478  * @note The status structures may contain a @c NULL ->entry field.
01479  * This indicates an item that is not versioned in the working copy.
01480  */
01481 
01482 enum svn_wc_status_kind
01483 {
01484     /** does not exist */
01485     svn_wc_status_none = 1,
01486 
01487     /** is not a versioned thing in this wc */
01488     svn_wc_status_unversioned,
01489 
01490     /** exists, but uninteresting */
01491     svn_wc_status_normal,
01492 
01493     /** is scheduled for addition */
01494     svn_wc_status_added,
01495 
01496     /** under v.c., but is missing */
01497     svn_wc_status_missing,
01498 
01499     /** scheduled for deletion */
01500     svn_wc_status_deleted,
01501 
01502     /** was deleted and then re-added */
01503     svn_wc_status_replaced,
01504 
01505     /** text or props have been modified */
01506     svn_wc_status_modified,
01507 
01508     /** local mods received repos mods */
01509     svn_wc_status_merged,
01510 
01511     /** local mods received conflicting repos mods */
01512     svn_wc_status_conflicted,
01513 
01514     /** a resource marked as ignored */
01515     svn_wc_status_ignored,
01516 
01517     /** an unversioned resource is in the way of the versioned resource */
01518     svn_wc_status_obstructed,
01519 
01520     /** an unversioned path populated by an svn:externals property */
01521     svn_wc_status_external,
01522 
01523     /** a directory doesn't contain a complete entries list */
01524     svn_wc_status_incomplete
01525 };
01526 
01527 /**
01528  * Structure for holding the "status" of a working copy item. 
01529  *
01530  * The item's entry data is in @a entry, augmented and possibly shadowed
01531  * by the other fields.  @a entry is @c NULL if this item is not under
01532  * version control.
01533  *
01534  * @note Fields may be added to the end of this structure in future
01535  * versions.  Therefore, users shouldn't allocate structures of this
01536  * type, to preserve binary compatibility.
01537  *
01538  * @since New in 1.2.
01539  */
01540 typedef struct svn_wc_status2_t
01541 {
01542   /** Can be @c NULL if not under version control. */
01543   svn_wc_entry_t *entry;
01544   
01545   /** The status of the entries text. */
01546   enum svn_wc_status_kind text_status;
01547 
01548   /** The status of the entries properties. */
01549   enum svn_wc_status_kind prop_status;
01550 
01551   /** a directory can be 'locked' if a working copy update was interrupted. */
01552   svn_boolean_t locked;
01553 
01554   /** a file or directory can be 'copied' if it's scheduled for 
01555    * addition-with-history (or part of a subtree that is scheduled as such.).
01556    */
01557   svn_boolean_t copied;
01558 
01559   /** a file or directory can be 'switched' if the switch command has been 
01560    * used.
01561    */
01562   svn_boolean_t switched;
01563 
01564   /** The entry's text status in the repository. */
01565   enum svn_wc_status_kind repos_text_status;
01566 
01567   /** The entry's property status in the repository. */
01568   enum svn_wc_status_kind repos_prop_status;
01569 
01570   /** The entry's lock in the repository, if any. */
01571   svn_lock_t *repos_lock;
01572 
01573   /** Set to the URI (actual or expected) of the item.
01574    * @since New in 1.3
01575    */
01576   const char *url;
01577 
01578   /**
01579    * @defgroup svn_wc_status_ood WC out of date info from the repository
01580    * @{
01581    *
01582    * When the working copy item is out of date compared to the
01583    * repository, the following fields represent the state of the
01584    * youngest revision of the item in the repository.  If the working
01585    * copy is not out of date, the fields are initialized as described
01586    * below.
01587    */
01588 
01589   /** Set to the youngest committed revision, or @c SVN_INVALID_REVNUM
01590    * if not out of date.
01591    * @since New in 1.3
01592    */
01593   svn_revnum_t ood_last_cmt_rev;
01594 
01595   /** Set to the most recent commit date, or @c 0 if not out of date.
01596    * @since New in 1.3
01597    */
01598   apr_time_t ood_last_cmt_date;
01599 
01600   /** Set to the node kind of the youngest commit, or @c svn_node_none
01601    * if not out of date.
01602    * @since New in 1.3
01603    */
01604   svn_node_kind_t ood_kind;
01605 
01606   /** Set to the user name of the youngest commit, or @c NULL if not
01607    * out of date or non-existent.  Because a non-existent @c
01608    * svn:author property has the same behavior as an out of date
01609    * working copy, examine @c ood_last_cmt_rev to determine whether
01610    * the working copy is out of date.
01611    * @since New in 1.3
01612    */
01613   const char *ood_last_cmt_author;
01614 
01615   /** @} */
01616 
01617 } svn_wc_status2_t;
01618 
01619 
01620 
01621 /**
01622  * Same as @c svn_wc_status2_t, but without the svn_lock_t 'repos_lock' field.
01623  *
01624  * @deprecated Provided for backward compatibility with the 1.1 API.
01625  */
01626 typedef struct svn_wc_status_t
01627 {
01628   /** Can be @c NULL if not under version control. */
01629   svn_wc_entry_t *entry;
01630   
01631   /** The status of the entries text. */
01632   enum svn_wc_status_kind text_status;
01633 
01634   /** The status of the entries properties. */
01635   enum svn_wc_status_kind prop_status;
01636 
01637   /** a directory can be 'locked' if a working copy update was interrupted. */
01638   svn_boolean_t locked;
01639 
01640   /** a file or directory can be 'copied' if it's scheduled for 
01641    * addition-with-history (or part of a subtree that is scheduled as such.).
01642    */
01643   svn_boolean_t copied;
01644 
01645   /** a file or directory can be 'switched' if the switch command has been 
01646    * used.
01647    */
01648   svn_boolean_t switched;
01649 
01650   /** The entry's text status in the repository. */
01651   enum svn_wc_status_kind repos_text_status;
01652 
01653   /** The entry's property status in the repository. */
01654   enum svn_wc_status_kind repos_prop_status;
01655 
01656 } svn_wc_status_t;
01657 
01658 
01659 
01660 /**
01661  * Return a deep copy of the @a orig_stat status structure, allocated
01662  * in @a pool.
01663  *
01664  * @since New in 1.2.
01665  */
01666 svn_wc_status2_t *svn_wc_dup_status2 (svn_wc_status2_t *orig_stat,
01667                                       apr_pool_t *pool);
01668 
01669 
01670 /**
01671  * Same as svn_wc_dup_status2(), but for older svn_wc_status_t structures.
01672  *
01673  * @deprecated Provided for backward compatibility with the 1.1 API.
01674  */
01675 svn_wc_status_t *svn_wc_dup_status (svn_wc_status_t *orig_stat,
01676                                     apr_pool_t *pool);
01677 
01678 
01679 /**
01680  * Fill @a *status for @a path, allocating in @a pool.
01681  * @a adm_access must be an access baton for @a path.
01682  *
01683  * Here are some things to note about the returned structure.  A quick
01684  * examination of the @c status->text_status after a successful return of
01685  * this function can reveal the following things:
01686  *
01687  *    - @c svn_wc_status_none : @a path is not versioned, and is either not
01688  *                              present on disk, or is ignored by svn's
01689  *                              default ignore regular expressions or the
01690  *                              svn:ignore property setting for @a path's
01691  *                              parent directory.
01692  *
01693  *    - @c svn_wc_status_missing : @a path is versioned, but is missing from
01694  *                                 the working copy.
01695  *
01696  *    - @c svn_wc_status_unversioned : @a path is not versioned, but is
01697  *                                     present on disk and not being
01698  *                                     ignored (see above).  
01699  *
01700  * The other available results for the @c text_status field are more
01701  * straightforward in their meanings.  See the comments on the
01702  * @c svn_wc_status_kind structure for some hints.
01703  *
01704  * @since New in 1.2.
01705  */
01706 svn_error_t *svn_wc_status2 (svn_wc_status2_t **status, 
01707                              const char *path, 
01708                              svn_wc_adm_access_t *adm_access,
01709                              apr_pool_t *pool);
01710 
01711 
01712 /**
01713  *  Same as svn_wc_status2(), but for older svn_wc_status_t structures.
01714  *
01715  * @deprecated Provided for backward compatibility with the 1.1 API.
01716  */
01717 svn_error_t *svn_wc_status (svn_wc_status_t **status, 
01718                             const char *path, 
01719                             svn_wc_adm_access_t *adm_access,
01720                             apr_pool_t *pool);
01721 
01722 
01723 
01724 
01725 /**
01726  * A callback for reporting a @a status about @a path. 
01727  *
01728  * @a baton is a closure object; it should be provided by the
01729  * implementation, and passed by the caller.
01730  *
01731  * @since New in 1.2.
01732  */
01733 typedef void (*svn_wc_status_func2_t) (void *baton,
01734                                        const char *path,
01735                                        svn_wc_status2_t *status);
01736 
01737 /**
01738  *  Same as svn_wc_status_func2_t(), but for older svn_wc_status_t structures.
01739  *
01740  * @deprecated Provided for backward compatibility with the 1.1 API.
01741  */
01742 typedef void (*svn_wc_status_func_t) (void *baton,
01743                                       const char *path,
01744                                       svn_wc_status_t *status);
01745 
01746 
01747 /**
01748  * Set @a *editor and @a *edit_baton to an editor that generates @c
01749  * svn_wc_status2_t structures and sends them through @a status_func /
01750  * @a status_baton.  @a anchor is an access baton, with a tree lock,
01751  * for the local path to the working copy which will be used as the
01752  * root of our editor.  If @a target is not empty, it represents an
01753  * entry in the @a anchor path which is the subject of the editor
01754  * drive (otherwise, the @a anchor is the subject).
01755  * 
01756  * If @a set_locks_baton is non-@c NULL, it will be set to a baton that can
01757  * be used in a call to the svn_wc_status_set_repos_locks() function.
01758  *
01759  * Callers drive this editor to describe working copy out-of-dateness
01760  * with respect to the repository.  If this information is not
01761  * available or not desired, callers should simply call the
01762  * close_edit() function of the @a editor vtable.
01763  *
01764  * If the editor driver calls @a editor's set_target_revision() vtable
01765  * function, then when the edit drive is completed, @a *edit_revision
01766  * will contain the revision delivered via that interface.
01767  *
01768  * @a config is a hash mapping @c SVN_CONFIG_CATEGORY's to @c
01769  * svn_config_t's.
01770  *
01771  * Assuming the target is a directory, then:
01772  * 
01773  *   - If @a get_all is false, then only locally-modified entries will be
01774  *     returned.  If true, then all entries will be returned.
01775  *
01776  *   - If @a recurse is false, status structures will be returned only
01777  *     for the target and its immediate children.  Otherwise, this
01778  *     operation is fully recursive.
01779  *
01780  * If @a no_ignore is set, statuses that would typically be ignored
01781  * will instead be reported.
01782  *
01783  * If @a cancel_func is non-null, call it with @a cancel_baton while building 
01784  * the @a statushash to determine if the client has cancelled the operation.
01785  *
01786  * If @a traversal_info is non-null, then record pre-update traversal
01787  * state in it.  (Caller should obtain @a traversal_info from
01788  * svn_wc_init_traversal_info().)
01789  *
01790  * Allocate the editor itself in @a pool, but the editor does temporary
01791  * allocations in a subpool of @a pool.
01792  *
01793  * @since New in 1.2.
01794  */
01795 svn_error_t *svn_wc_get_status_editor2 (const svn_delta_editor_t **editor,
01796                                         void **edit_baton,
01797                                         void **set_locks_baton,
01798                                         svn_revnum_t *edit_revision,
01799                                         svn_wc_adm_access_t *anchor,
01800                                         const char *target,
01801                                         apr_hash_t *config,
01802                                         svn_boolean_t recurse,
01803                                         svn_boolean_t get_all,
01804                                         svn_boolean_t no_ignore,
01805                                         svn_wc_status_func2_t status_func,
01806                                         void *status_baton,
01807                                         svn_cancel_func_t cancel_func,
01808                                         void *cancel_baton,
01809                                         svn_wc_traversal_info_t *traversal_info,
01810                                         apr_pool_t *pool);
01811 
01812 
01813 /**
01814  * Same as svn_wc_get_status_editor2(), but with @a set_locks_baton set
01815  * to @c NULL, and taking a deprecated svn_wc_status_func_t argument.
01816  *
01817  * @deprecated Provided for backward compatibility with the 1.1 API.
01818  */
01819 svn_error_t *svn_wc_get_status_editor (const svn_delta_editor_t **editor,
01820                                        void **edit_baton,
01821                                        svn_revnum_t *edit_revision,
01822                                        svn_wc_adm_access_t *anchor,
01823                                        const char *target,
01824                                        apr_hash_t *config,
01825                                        svn_boolean_t recurse,
01826                                        svn_boolean_t get_all,
01827                                        svn_boolean_t no_ignore,
01828                                        svn_wc_status_func_t status_func,
01829                                        void *status_baton,
01830                                        svn_cancel_func_t cancel_func,
01831                                        void *cancel_baton,
01832                                        svn_wc_traversal_info_t *traversal_info,
01833                                        apr_pool_t *pool);
01834 
01835 
01836 /**
01837  * Associate @a locks, a hash table mapping <tt>const char*</tt>
01838  * absolute repository paths to <tt>svn_lock_t</tt> objects, with a
01839  * @a set_locks_baton returned by an earlier call to
01840  * svn_wc_get_status_editor2().  @a repos_root is the repository root URL.
01841  * Perform all allocations in @a pool.
01842  *
01843  * @note @a locks will not be copied, so it must be valid throughout the
01844  * edit.  @a pool must also not be destroyed or cleared before the edit is
01845  * finished.
01846  *
01847  * @since New in 1.2.
01848  */
01849 svn_error_t *
01850 svn_wc_status_set_repos_locks (void *set_locks_baton,
01851                                apr_hash_t *locks,
01852                                const char *repos_root,
01853                                apr_pool_t *pool);
01854 
01855 /** @} */
01856 
01857 
01858 /**
01859  * Copy @a src to @a dst_basename in @a dst_parent, and schedule 
01860  * @a dst_basename for addition to the repository, remembering the copy 
01861  * history.
01862  *
01863  * @a src must be a file or directory under version control; @a dst_parent
01864  * must be a directory under version control in the same working copy;
01865  * @a dst_basename will be the name of the copied item, and it must not
01866  * exist already.
01867  *
01868  * If @a cancel_func is non-null, call it with @a cancel_baton at
01869  * various points during the operation.  If it returns an error
01870  * (typically @c SVN_ERR_CANCELLED), return that error immediately.
01871  *
01872  * For each file or directory copied, @a notify_func will be called
01873  * with its path and the @a notify_baton.  @a notify_func may be @c NULL 
01874  * if you are not interested in this information.
01875  *
01876  * @par Important:
01877  * This is a variant of svn_wc_add().  No changes will happen
01878  * to the repository until a commit occurs.  This scheduling can be
01879  * removed with svn_client_revert().
01880  *
01881  * @since New in 1.2.
01882  */
01883 svn_error_t *svn_wc_copy2 (const char *src,
01884                            svn_wc_adm_access_t *dst_parent,
01885                            const char *dst_basename,
01886                            svn_cancel_func_t cancel_func,
01887                            void *cancel_baton,
01888                            svn_wc_notify_func2_t notify_func,
01889                            void *notify_baton,
01890                            apr_pool_t *pool);
01891 
01892 /**
01893  * Similar to svn_wc_copy2(), but takes an @c svn_wc_notify_func_t instead.
01894  *
01895  * @deprecated Provided for backward compatibility with the 1.1 API.
01896  */
01897 svn_error_t *svn_wc_copy (const char *src,
01898                           svn_wc_adm_access_t *dst_parent,
01899                           const char *dst_basename,
01900                           svn_cancel_func_t cancel_func,
01901                           void *cancel_baton,
01902                           svn_wc_notify_func_t notify_func,
01903                           void *notify_baton,
01904                           apr_pool_t *pool);
01905 
01906 /**
01907  * Schedule @a path for deletion, it will be deleted from the repository on
01908  * the next commit.  If @a path refers to a directory, then a recursive
01909  * deletion will occur.  @a adm_access must hold a write lock for the parent 
01910  * of @a path.
01911  *
01912  * This function immediately deletes all files, modified and unmodified,
01913  * versioned and unversioned from the working copy. It also immediately
01914  * deletes unversioned directories and directories that are scheduled to be
01915  * added.  Only versioned directories will remain in the working copy,
01916  * these get deleted by the update following the commit.
01917  *
01918  * If @a cancel_func is non-null, call it with @a cancel_baton at
01919  * various points during the operation.  If it returns an error
01920  * (typically @c SVN_ERR_CANCELLED), return that error immediately.
01921  *
01922  * For each path marked for deletion, @a notify_func will be called with
01923  * the @a notify_baton and that path. The @a notify_func callback may be
01924  * @c NULL if notification is not needed.
01925  *
01926  * @since New in 1.2.
01927  */
01928 svn_error_t *svn_wc_delete2 (const char *path,
01929                              svn_wc_adm_access_t *adm_access,
01930                              svn_cancel_func_t cancel_func,
01931                              void *cancel_baton,
01932                              svn_wc_notify_func2_t notify_func,
01933                              void *notify_baton,
01934                              apr_pool_t *pool);
01935 
01936 /**
01937  * Similar to svn_wc_delete2(), but takes an @c svn_wc_notify_func_t instead.
01938  *
01939  * @deprecated Provided for backward compatibility with the 1.1 API.
01940  */
01941 svn_error_t *svn_wc_delete (const char *path,
01942                             svn_wc_adm_access_t *adm_access,
01943                             svn_cancel_func_t cancel_func,
01944                             void *cancel_baton,
01945                             svn_wc_notify_func_t notify_func,
01946                             void *notify_baton,
01947                             apr_pool_t *pool);
01948 
01949 
01950 /**
01951  * Put @a path under version control by adding an entry in its parent,
01952  * and, if @a path is a directory, adding an administrative area.  The
01953  * new entry and anything under it is scheduled for addition to the
01954  * repository.  @a parent_access should hold a write lock for the parent
01955  * directory of @a path.  If @a path is a directory then an access baton 
01956  * for @a path will be added to the set containing @a parent_access.
01957  *
01958  * If @a path does not exist, return @c SVN_ERR_WC_PATH_NOT_FOUND.
01959  *
01960  * If @a copyfrom_url is non-null, it and @a copyfrom_rev are used as
01961  * `copyfrom' args.  This is for copy operations, where one wants
01962  * to schedule @a path for addition with a particular history.
01963  *
01964  * If @a cancel_func is non-null, call it with @a cancel_baton at
01965  * various points during the operation.  If it returns an error
01966  * (typically @c SVN_ERR_CANCELLED), return that error immediately.
01967  *
01968  * When the @a path has been added, then @a notify_func will be called
01969  * (if it is not @c NULL) with the @a notify_baton and the path.
01970  *
01971  * Return @c SVN_ERR_WC_NODE_KIND_CHANGE if @a path is both an unversioned
01972  * directory and a file that is scheduled for deletion or in state deleted.
01973  *
01974  *<pre> ### This function currently does double duty -- it is also
01975  * ### responsible for "switching" a working copy directory over to a
01976  * ### new copyfrom ancestry and scheduling it for addition.  Here is
01977  * ### the old doc string from Ben, lightly edited to bring it
01978  * ### up-to-date, explaining the true, secret life of this function:</pre>
01979  *
01980  * Given a @a path within a working copy of type KIND, follow this algorithm:
01981  *
01982  *    - if @a path is not under version control:
01983  *       - Place it under version control and schedule for addition; 
01984  *         if @a copyfrom_url is non-null, use it and @a copyfrom_rev as
01985  *         'copyfrom' history
01986  *
01987  *    - if @a path is already under version control:
01988  *          (This can only happen when a directory is copied, in which
01989  *           case ancestry must have been supplied as well.)
01990  *
01991  *       -  Schedule the directory itself for addition with copyfrom history.
01992  *       -  Mark all its children with a 'copied' flag
01993  *       -  Rewrite all the URLs to what they will be after a commit.
01994  *       -  ### TODO:  remove old wcprops too, see the '###'below
01995  *
01996  *<pre> ### I think possibly the "switchover" functionality should be
01997  * ### broken out into a separate function, but its all intertwined in
01998  * ### the code right now.  Ben, thoughts?  Hard?  Easy?  Mauve?</pre>
01999  *
02000  * ### Update: see "###" comment in svn_wc_add_repos_file()'s doc
02001  * string about this.
02002  *
02003  * @since New in 1.2.
02004  */
02005 svn_error_t *svn_wc_add2 (const char *path,
02006                           svn_wc_adm_access_t *parent_access,
02007                           const char *copyfrom_url,
02008                           svn_revnum_t copyfrom_rev,
02009                           svn_cancel_func_t cancel_func,
02010                           void *cancel_baton,
02011                           svn_wc_notify_func2_t notify_func,
02012                           void *notify_baton,
02013                           apr_pool_t *pool);
02014 
02015 /**
02016  * Similar to svn_wc_add2(), but takes an @c svn_wc_notify_func_t instead.
02017  *
02018  * @deprecated Provided for backward compatibility with the 1.1 API.
02019  */
02020 svn_error_t *svn_wc_add (const char *path,
02021                          svn_wc_adm_access_t *parent_access,
02022                          const char *copyfrom_url,
02023                          svn_revnum_t copyfrom_rev,
02024                          svn_cancel_func_t cancel_func,
02025                          void *cancel_baton,
02026                          svn_wc_notify_func_t notify_func,
02027                          void *notify_baton,
02028                          apr_pool_t *pool);
02029 
02030 /** Add a file to a working copy at @a dst_path, obtaining the file's
02031  * contents from @a new_text_path and its properties from @a new_props,
02032  * which normally come from the repository file represented by the
02033  * copyfrom args, see below.  The new file will be scheduled for
02034  * addition with history.
02035  *
02036  * Automatically remove @a new_text_path upon successful completion.
02037  *
02038  * @a adm_access, or an access baton in its associated set, must
02039  * contain a write lock for the parent of @a dst_path.
02040  *
02041  * If @a copyfrom_url is non-null, then @a copyfrom_rev must be a
02042  * valid revision number, and together they are the copyfrom history
02043  * for the new file.
02044  *
02045  * Use @a pool for temporary allocations.
02046  *
02047  * ### This function is very redundant with svn_wc_add().  Ideally,
02048  * we'd merge them, so that svn_wc_add() would just take optional
02049  * new_props and optional copyfrom information.  That way it could be
02050  * used for both 'svn add somefilesittingonmydisk' and for adding
02051  * files from repositories, with or without copyfrom history.
02052  *
02053  * The problem with this Ideal Plan is that svn_wc_add() also takes
02054  * care of recursive URL-rewriting.  There's a whole comment in its
02055  * doc string about how that's really weird, outside its core mission,
02056  * etc, etc.  So another part of the Ideal Plan is that that
02057  * functionality of svn_wc_add() would move into a separate function.
02058  */
02059 svn_error_t *svn_wc_add_repos_file (const char *dst_path,
02060                                     svn_wc_adm_access_t *adm_access,
02061                                     const char *new_text_path,
02062                                     apr_hash_t *new_props,
02063                                     const char *copyfrom_url,
02064                                     svn_revnum_t copyfrom_rev,
02065                                     apr_pool_t *pool);
02066 
02067 
02068 /** Remove entry @a name in @a adm_access from revision control.  @a name 
02069  * must be either a file or @c SVN_WC_ENTRY_THIS_DIR.  @a adm_access must 
02070  * hold a write lock.
02071  *
02072  * If @a name is a file, all its info will be removed from @a adm_access's
02073  * administrative directory.  If @a name is @c SVN_WC_ENTRY_THIS_DIR, then
02074  * @a adm_access's entire administrative area will be deleted, along with
02075  * *all* the administrative areas anywhere in the tree below @a adm_access.
02076  *
02077  * Normally, only administrative data is removed.  However, if
02078  * @a destroy_wf is true, then all working file(s) and dirs are deleted
02079  * from disk as well.  When called with @a destroy_wf, any locally
02080  * modified files will *not* be deleted, and the special error
02081  * @c SVN_ERR_WC_LEFT_LOCAL_MOD might be returned.  (Callers only need to
02082  * check for this special return value if @a destroy_wf is true.)
02083  *
02084  * If @a instant_error is TRUE, then return @c
02085  * SVN_ERR_WC_LEFT_LOCAL_MOD the instant a locally modified file is
02086  * encountered.  Otherwise, leave locally modified files in place and
02087  * return the error only after all the recursion is complete.
02088  *
02089  * If @a cancel_func is non-null, call it with @a cancel_baton at
02090  * various points during the removal.  If it returns an error
02091  * (typically @c SVN_ERR_CANCELLED), return that error immediately.
02092  *
02093  * WARNING:  This routine is exported for careful, measured use by
02094  * libsvn_client.  Do *not* call this routine unless you really
02095  * understand what the heck you're doing.
02096  */
02097 svn_error_t *
02098 svn_wc_remove_from_revision_control (svn_wc_adm_access_t *adm_access,
02099                                      const char *name,
02100                                      svn_boolean_t destroy_wf,
02101                                      svn_boolean_t instant_error,
02102                                      svn_cancel_func_t cancel_func,
02103                                      void *cancel_baton,
02104                                      apr_pool_t *pool);
02105 
02106 
02107 /**
02108  * Assuming @a path is under version control and in a state of conflict, 
02109  * then take @a path *out* of this state.  If @a resolve_text is true then 
02110  * any text conflict is resolved, if @a resolve_props is true then any 
02111  * property conflicts are resolved.  If @a recurse is true, then search
02112  * recursively for conflicts to resolve.
02113  *
02114  * @a adm_access is an access baton, with a write lock, for @a path.
02115  *
02116  * Needless to say, this function doesn't touch conflict markers or
02117  * anything of that sort -- only a human can semantically resolve a
02118  * conflict.  Instead, this function simply marks a file as "having
02119  * been resolved", clearing the way for a commit.  
02120  *
02121  * The implementation details are opaque, as our "conflicted" criteria
02122  * might change over time.  (At the moment, this routine removes the
02123  * three fulltext 'backup' files and any .prej file created in a conflict,
02124  * and modifies @a path's entry.)
02125  *
02126  * If @a path is not under version control, return @c SVN_ERR_ENTRY_NOT_FOUND.  
02127  * If @a path isn't in a state of conflict to begin with, do nothing, and
02128  * return @c SVN_NO_ERROR.
02129  *
02130  * If @c path was successfully taken out of a state of conflict, report this
02131  * information to @c notify_func (if non-@c NULL.)  If only text or only 
02132  * property conflict resolution was requested, and it was successful, then 
02133  * success gets reported.
02134  *
02135  * @since New in 1.2.
02136  */
02137 svn_error_t *svn_wc_resolved_conflict2 (const char *path,
02138                                         svn_wc_adm_access_t *adm_access,
02139                                         svn_boolean_t resolve_text,
02140                                         svn_boolean_t resolve_props,
02141                                         svn_boolean_t recurse,
02142                                         svn_wc_notify_func2_t notify_func,
02143                                         void *notify_baton,
02144                                         svn_cancel_func_t cancel_func,
02145                                         void *cancel_baton,
02146                                         apr_pool_t *pool);
02147 
02148 /**
02149  * Similar to svn_wc_resolved_conflict2(), but takes an
02150  * svn_wc_notify_func_t and doesn't have cancellation support.
02151  *
02152  * @deprecated Provided for backward compatibility with the 1.0 API.
02153  */
02154 svn_error_t *svn_wc_resolved_conflict (const char *path,
02155                                        svn_wc_adm_access_t *adm_access,
02156                                        svn_boolean_t resolve_text,
02157                                        svn_boolean_t resolve_props,
02158                                        svn_boolean_t recurse,
02159                                        svn_wc_notify_func_t notify_func,
02160                                        void *notify_baton,
02161                                        apr_pool_t *pool);
02162 
02163 
02164 /* Commits. */
02165 
02166 /**
02167  * Bump a successfully committed absolute @a path to @a new_revnum after a
02168  * commit succeeds.  @a rev_date and @a rev_author are the (server-side)
02169  * date and author of the new revision; one or both may be @c NULL.
02170  * @a adm_access must hold a write lock appropriate for @a path.
02171  *
02172  * If non-null, @a wcprops is an array of <tt>svn_prop_t *</tt> changes to 
02173  * wc properties; if an @c svn_prop_t->value is null, then that property is
02174  * deleted.
02175  *
02176  * If @a remove_lock is @c TRUE, any entryprops related to a repository
02177  * lock will be removed.
02178  *
02179  * If @a recurse is true and @a path is a directory, then bump every
02180  * versioned object at or under @a path.  This is usually done for
02181  * copied trees.
02182  *
02183  * @since New in 1.2.
02184  */
02185 svn_error_t *svn_wc_process_committed2 (const char *path,
02186                                         svn_wc_adm_access_t *adm_access,
02187                                         svn_boolean_t recurse,
02188                                         svn_revnum_t new_revnum,
02189                                         const char *rev_date,
02190                                         const char *rev_author,
02191                                         apr_array_header_t *wcprop_changes,
02192                                         svn_boolean_t remove_lock,
02193                                         apr_pool_t *pool);
02194 
02195 
02196 /**
02197  * Similar to svn_wc_process_committed2(), but with @a remove_lock set to
02198  * @c FALSE.
02199  *
02200  * @deprecated Provided for backward compatibility with the 1.1 API.
02201  */
02202 svn_error_t *svn_wc_process_committed (const char *path,
02203                                        svn_wc_adm_access_t *adm_access,
02204                                        svn_boolean_t recurse,
02205                                        svn_revnum_t new_revnum,
02206                                        const char *rev_date,
02207                                        const char *rev_author,
02208                                        apr_array_header_t *wcprop_changes,
02209                                        apr_pool_t *pool);
02210 
02211 
02212 
02213 
02214 
02215 /**
02216  * Do a depth-first crawl in a working copy, beginning at @a path.
02217  *
02218  * Communicate the `state' of the working copy's revisions to
02219  * @a reporter/@a report_baton.  Obviously, if @a path is a file instead 
02220  * of a directory, this depth-first crawl will be a short one.
02221  *
02222  * No locks are or logs are created, nor are any animals harmed in the
02223  * process.  No cleanup is necessary.  @a adm_access must be an access 
02224  * baton for the @a path hierarchy, it does not require a write lock.
02225  *
02226  * After all revisions are reported, @a reporter->finish_report() is
02227  * called, which immediately causes the RA layer to update the working
02228  * copy.  Thus the return value may very well reflect the result of
02229  * the update!
02230  *
02231  * If @a restore_files is true, then unexpectedly missing working files
02232  * will be restored from the administrative directory's cache. For each
02233  * file restored, the @a notify_func function will be called with the
02234  * @a notify_baton and the path of the restored file. @a notify_func may
02235  * be @c NULL if this notification is not required.  If @a
02236  * use_commit_times is true, then set restored files' timestamps to
02237  * their last-commit-times.
02238  *
02239  * If @a traversal_info is non-null, then record pre-update traversal
02240  * state in it.  (Caller should obtain @a traversal_info from
02241  * svn_wc_init_traversal_info().)
02242  *
02243  * @since New in 1.2.
02244  */
02245 svn_error_t *
02246 svn_wc_crawl_revisions2 (const char *path,
02247                          svn_wc_adm_access_t *adm_access,
02248                          const svn_ra_reporter2_t *reporter,
02249                          void *report_baton,
02250                          svn_boolean_t restore_files,
02251                          svn_boolean_t recurse,
02252                          svn_boolean_t use_commit_times,
02253                          svn_wc_notify_func2_t notify_func,
02254                          void *notify_baton,
02255                          svn_wc_traversal_info_t *traversal_info,
02256                          apr_pool_t *pool);
02257 
02258 /**
02259  * Similar to svn_wc_crawl_revisions2(), but takes an svn_wc_notify_func_t
02260  * and a @c svn_reporter_t instead.
02261  *
02262  * @deprecated Provided for backward compatibility with the 1.1 API.
02263  */
02264 svn_error_t *
02265 svn_wc_crawl_revisions (const char *path,
02266                         svn_wc_adm_access_t *adm_access,
02267                         const svn_ra_reporter_t *reporter,
02268                         void *report_baton,
02269                         svn_boolean_t restore_files,
02270                         svn_boolean_t recurse,
02271                         svn_boolean_t use_commit_times,
02272                         svn_wc_notify_func_t notify_func,
02273                         void *notify_baton,
02274                         svn_wc_traversal_info_t *traversal_info,
02275                         apr_pool_t *pool);
02276 
02277 
02278 /* Updates. */
02279 
02280 /** Set @a *wc_root to @c TRUE if @a path represents a "working copy root",
02281  * @c FALSE otherwise.  Use @a pool for any intermediate allocations.
02282  *
02283  * If @a path is not found, return the error @c SVN_ERR_ENTRY_NOT_FOUND.
02284  *
02285  * @note Due to the way in which "WC-root-ness" is calculated, passing
02286  * a @a path of `.' to this function will always return @c TRUE.
02287  */
02288 svn_error_t *svn_wc_is_wc_root (svn_boolean_t *wc_root,
02289                                 const char *path,
02290                                 svn_wc_adm_access_t *adm_access,
02291                                 apr_pool_t *pool);
02292 
02293 
02294 /** Conditionally split @a path into an @a anchor and @a target for the 
02295  * purpose of updating and committing.
02296  *
02297  * @a anchor is the directory at which the update or commit editor
02298  * should be rooted.
02299  *
02300  * @a target is the actual subject (relative to the @a anchor) of the
02301  * update/commit, or "" if the @a anchor itself is the subject.
02302  *
02303  * Allocate @a anchor and @a target in @a pool.  
02304  */
02305 svn_error_t *svn_wc_get_actual_target (const char *path,
02306                                        const char **anchor,
02307                                        const char **target,
02308                                        apr_pool_t *pool);
02309 
02310 
02311 
02312 /* Update and update-like functionality. */
02313 
02314 /**
02315  * Set @a *editor and @a *edit_baton to an editor and baton for updating a
02316  * working copy.
02317  *
02318  * If @a ti is non-null, record traversal info in @a ti, for use by
02319  * post-traversal accessors such as svn_wc_edited_externals().
02320  * 
02321  * @a anchor is an access baton, with a write lock, for the local path to the
02322  * working copy which will be used as the root of our editor.  Further
02323  * locks will be acquired if the update creates new directories.  All
02324  * locks, both those in @a anchor and newly acquired ones, will be released
02325  * when the editor driver calls @c close_edit.
02326  *
02327  * @a target is the entry in @a anchor that will actually be updated, or 
02328  * empty if all of @a anchor should be updated.
02329  *
02330  * The editor invokes @a notify_func with @a notify_baton as the update
02331  * progresses, if @a notify_func is non-null.
02332  *
02333  * If @a cancel_func is non-null, the editor will invoke @a cancel_func with 
02334  * @a cancel_baton as the update progresses to see if it should continue.
02335  *
02336  * If @a diff3_cmd is non-null, then use it as the diff3 command for
02337  * any merging; otherwise, use the built-in merge code.
02338  *
02339  * @a target_revision is a pointer to a revision location which, after
02340  * successful completion of the drive of this editor, will be
02341  * populated with the revision to which the working copy was updated.
02342  *
02343  * If @a use_commit_times is TRUE, then all edited/added files will
02344  * have their working timestamp set to the last-committed-time.  If
02345  * FALSE, the working files will be touched with the 'now' time.
02346  *
02347  * @since New in 1.2.
02348  */
02349 svn_error_t *svn_wc_get_update_editor2 (svn_revnum_t *target_revision,
02350                                         svn_wc_adm_access_t *anchor,
02351                                         const char *target,
02352                                         svn_boolean_t use_commit_times,
02353                                         svn_boolean_t recurse,
02354                                         svn_wc_notify_func2_t notify_func,
02355                                         void *notify_baton,
02356                                         svn_cancel_func_t cancel_func,
02357                                         void *cancel_baton,
02358                                         const char *diff3_cmd,
02359                                         const svn_delta_editor_t **editor,
02360                                         void **edit_baton,
02361                                         svn_wc_traversal_info_t *ti,
02362                                         apr_pool_t *pool);
02363 
02364 /**
02365  * Similar to svn_wc_get_update_editor2(), but takes an svn_wc_notify_func_t
02366  * instead.
02367  *
02368  * @deprecated Provided for backward compatibility with the 1.1 API.
02369  */
02370 svn_error_t *svn_wc_get_update_editor (svn_revnum_t *target_revision,
02371                                        svn_wc_adm_access_t *anchor,
02372                                        const char *target,
02373                                        svn_boolean_t use_commit_times,
02374                                        svn_boolean_t recurse,
02375                                        svn_wc_notify_func_t notify_func,
02376                                        void *notify_baton,
02377                                        svn_cancel_func_t cancel_func,
02378                                        void *cancel_baton,
02379                                        const char *diff3_cmd,
02380                                        const svn_delta_editor_t **editor,
02381                                        void **edit_baton,
02382                                        svn_wc_traversal_info_t *ti,
02383                                        apr_pool_t *pool);
02384 
02385 /**
02386  * A variant of svn_wc_get_update_editor().
02387  *
02388  * Set @a *editor and @a *edit_baton to an editor and baton for "switching"
02389  * a working copy to a new @a switch_url.  (Right now, this URL must be
02390  * within the same repository that the working copy already comes
02391  * from.)  @a switch_url must not be @c NULL.
02392  *
02393  * If @a ti is non-null, record traversal info in @a ti, for use by
02394  * post-traversal accessors such as svn_wc_edited_externals().
02395  * 
02396  * @a anchor is an access baton, with a write lock, for the local path to the
02397  * working copy which will be used as the root of our editor.  Further
02398  * locks will be acquired if the switch creates new directories.  All
02399  * locks, both those in @a anchor and newly acquired ones, will be released
02400  * when the editor driver calls @c close_edit.
02401  *
02402  * @a target is the entry in @a anchor that will actually be updated, or 
02403  * empty if all of @a anchor should be updated.
02404  *
02405  * The editor invokes @a notify_func with @a notify_baton as the switch
02406  * progresses, if @a notify_func is non-null.
02407  *
02408  * If @a cancel_func is non-null, it will be called with @a cancel_baton as 
02409  * the switch progresses to determine if it should continue.
02410  *
02411  * If @a diff3_cmd is non-null, then use it as the diff3 command for
02412  * any merging; otherwise, use the built-in merge code.
02413  *
02414  * @a target_revision is a pointer to a revision location which, after
02415  * successful completion of the drive of this editor, will be
02416  * populated with the revision to which the working copy was updated.
02417  *
02418  * If @a use_commit_times is TRUE, then all edited/added files will
02419  * have their working timestamp set to the last-committed-time.  If
02420  * FALSE, the working files will be touched with the 'now' time.
02421  *
02422  * @since New in 1.2.
02423  */
02424 svn_error_t *svn_wc_get_switch_editor2 (svn_revnum_t *target_revision,
02425                                         svn_wc_adm_access_t *anchor,
02426                                         const char *target,
02427                                         const char *switch_url,
02428                                         svn_boolean_t use_commit_times,
02429                                         svn_boolean_t recurse,
02430                                         svn_wc_notify_func2_t notify_func,
02431                                         void *notify_baton,
02432                                         svn_cancel_func_t cancel_func,
02433                                         void *cancel_baton,
02434                                         const char *diff3_cmd,
02435                                         const svn_delta_editor_t **editor,
02436                                         void **edit_baton,
02437                                         svn_wc_traversal_info_t *ti,
02438                                         apr_pool_t *pool);
02439 
02440 /**
02441  * Similar to svn_wc_get_switch_editor2(), but takes an
02442  * @c svn_wc_notify_func_t instead.
02443  *
02444  * @deprecated Provided for backward compatibility with the 1.1 API.
02445  */
02446 svn_error_t *svn_wc_get_switch_editor (svn_revnum_t *target_revision,
02447                                        svn_wc_adm_access_t *anchor,
02448                                        const char *target,
02449                                        const char *switch_url,
02450                                        svn_boolean_t use_commit_times,
02451                                        svn_boolean_t recurse,
02452                                        svn_wc_notify_func_t notify_func,
02453                                        void *notify_baton,
02454                                        svn_cancel_func_t cancel_func,
02455                                        void *cancel_baton,
02456                                        const char *diff3_cmd,
02457                                        const svn_delta_editor_t **editor,
02458                                        void **edit_baton,
02459                                        svn_wc_traversal_info_t *ti,
02460                                        apr_pool_t *pool);
02461 
02462 
02463 
02464 /* A word about the implementation of working copy property storage:
02465  *
02466  * Since properties are key/val pairs, you'd think we store them in
02467  * some sort of Berkeley DB-ish format, and even store pending changes
02468  * to them that way too.
02469  *
02470  * However, we already have libsvn_subr/hashdump.c working, and it
02471  * uses a human-readable format.  That will be very handy when we're
02472  * debugging, and presumably we will not be dealing with any huge
02473  * properties or property lists initially.  Therefore, we will
02474  * continue to use hashdump as the internal mechanism for storing and
02475  * reading from property lists, but note that the interface here is
02476  * _not_ dependent on that.  We can swap in a DB-based implementation
02477  * at any time and users of this library will never know the
02478  * difference.
02479  */
02480 
02481 /** Set @a *props to a hash table mapping <tt>char *</tt> names onto
02482  * <tt>svn_string_t *</tt> values for all the regular properties of 
02483  * @a path.  Allocate the table, names, and values in @a pool.  If 
02484  * the node has no properties, an empty hash is returned.  @a adm_access
02485  * is an access baton set that contains @a path.
02486  */
02487 svn_error_t *svn_wc_prop_list (apr_hash_t **props,
02488                                const char *path,
02489                                svn_wc_adm_access_t *adm_access,
02490                                apr_pool_t *pool);
02491 
02492 
02493 /** Set @a *value to the value of property @a name for @a path, allocating
02494  * @a *value in @a pool.  If no such prop, set @a *value to @c NULL.  
02495  * @a name may be a regular or wc property; if it is an entry property, 
02496  * return the error @c SVN_ERR_BAD_PROP_KIND.  @a adm_access is an access
02497  * baton set that contains @a path.
02498  */
02499 svn_error_t *svn_wc_prop_get (const svn_string_t **value,
02500                               const char *name,
02501                               const char *path,
02502                               svn_wc_adm_access_t *adm_access,
02503                               apr_pool_t *pool);
02504 
02505 /** 
02506  * Set property @a name to @a value for @a path, or if @a value is
02507  * null, remove property @a name from @a path.  @a adm_access is an
02508  * access baton with a write lock for @a path.
02509  *
02510  * If @a skip_checks is true, do no validity checking.  But if @a
02511  * skip_checks is false, and @a name is not a valid property for @a
02512  * path, return an error, either @c SVN_ERR_ILLEGAL_TARGET (if the
02513  * property is not appropriate for @a path), or @c
02514  * SVN_ERR_BAD_MIME_TYPE (if @a name is "svn:mime-type", but @a value
02515  * is not a valid mime-type).
02516  *
02517  * @a name may be a wc property or a regular property; but if it is an
02518  * entry property, return the error @c SVN_ERR_BAD_PROP_KIND, even if
02519  * @a skip_checks is true.
02520  *
02521  * Use @a pool for temporary allocation.  
02522  * 
02523  * @since New in 1.2.
02524  */
02525 svn_error_t *svn_wc_prop_set2 (const char *name,
02526                                const svn_string_t *value,
02527                                const char *path,
02528                                svn_wc_adm_access_t *adm_access,
02529                                svn_boolean_t skip_checks,
02530                                apr_pool_t *pool);
02531 
02532 
02533 /**
02534  * Like svn_wc_prop_set2(), but with @a skip_checks always false.
02535  *
02536  * @deprecated Provided for backward compatibility with the 1.1 API.
02537  */
02538 svn_error_t *svn_wc_prop_set (const char *name,
02539                               const svn_string_t *value,
02540                               const char *path,
02541                               svn_wc_adm_access_t *adm_access,
02542                               apr_pool_t *pool);
02543 
02544 
02545 /** Return true iff @a name is a 'normal' property name.  'Normal' is
02546  * defined as a user-visible and user-tweakable property that shows up
02547  * when you fetch a proplist.
02548  *
02549  * The function currently parses the namespace like so:
02550  *
02551  *   - 'svn:wc:'  ==>  a wcprop, stored/accessed separately via different API.
02552  *
02553  *   - 'svn:entry:' ==> an "entry" prop, shunted into the 'entries' file.
02554  *
02555  * If these patterns aren't found, then the property is assumed to be
02556  * Normal.
02557  */
02558 svn_boolean_t svn_wc_is_normal_prop (const char *name);
02559 
02560 
02561 
02562 /** Return true iff @a name is a 'wc' property name. */
02563 svn_boolean_t svn_wc_is_wc_prop (const char *name);
02564 
02565 /** Return true iff @a name is a 'entry' property name. */
02566 svn_boolean_t svn_wc_is_entry_prop (const char *name);
02567 
02568 
02569 
02570 
02571 /* Diffs */
02572 
02573 
02574 /**
02575  * Return an @a editor/@a edit_baton for diffing a working copy against the
02576  * repository.
02577  *
02578  * @a anchor/@a target represent the base of the hierarchy to be compared.
02579  *
02580  * @a callbacks/@a callback_baton is the callback table to use when two
02581  * files are to be compared.
02582  *
02583  * @a recurse determines whether to descend into subdirectories when @a target
02584  * is a directory.  If @a recurse is @c TRUE then @a anchor should be part of 
02585  * an access baton set for the @a target hierarchy.
02586  *
02587  * @a ignore_ancestry determines whether paths that have discontinuous node
02588  * ancestry are treated as delete/add or as simple modifications.  If
02589  * @a ignore_ancestry is @c FALSE, then any discontinuous node ancestry will
02590  * result in the diff given as a full delete followed by an add.
02591  *
02592  * If @a use_text_base is true, then compare the repository against
02593  * the working copy's text-base files, rather than the working files.
02594  *
02595  * Normally, the difference from repository->working_copy is shown.
02596  * If @ reverse_order is true, then show working_copy->repository diffs.
02597  *
02598  * If @a cancel_func is non-null, it will be used along with @a cancel_baton 
02599  * to periodically check if the client has canceled the operation.
02600  *
02601  * @since New in 1.2.
02602  */
02603 svn_error_t *svn_wc_get_diff_editor3 (svn_wc_adm_access_t *anchor,
02604                                       const char *target,
02605                                       const svn_wc_diff_callbacks2_t *callbacks,
02606                                       void *callback_baton,
02607                                       svn_boolean_t recurse,
02608                                       svn_boolean_t ignore_ancestry,
02609                                       svn_boolean_t use_text_base,
02610                                       svn_boolean_t reverse_order,
02611                                       svn_cancel_func_t cancel_func,
02612                                       void *cancel_baton,
02613                                       const svn_delta_editor_t **editor,
02614                                       void **edit_baton,
02615                                       apr_pool_t *pool);
02616 
02617 
02618 /**
02619  * Similar to svn_wc_get_diff_editor3(), but with an
02620  * @c svn_wc_diff_callbacks_t instead of @c svn_wc_diff_callbacks2_t.
02621  *
02622  * @deprecated Provided for backward compatibility with the 1.1 API.
02623  */
02624 svn_error_t *svn_wc_get_diff_editor2 (svn_wc_adm_access_t *anchor,
02625                                       const char *target,
02626                                       const svn_wc_diff_callbacks_t *callbacks,
02627                                       void *callback_baton,
02628                                       svn_boolean_t recurse,
02629                                       svn_boolean_t ignore_ancestry,
02630                                       svn_boolean_t use_text_base,
02631                                       svn_boolean_t reverse_order,
02632                                       svn_cancel_func_t cancel_func,
02633                                       void *cancel_baton,
02634                                       const svn_delta_editor_t **editor,
02635                                       void **edit_baton,
02636                                       apr_pool_t *pool);
02637 
02638 
02639 /**
02640  * Similar to svn_wc_get_diff_editor2(), but with @a ignore_ancestry
02641  * always set to @c FALSE.
02642  *
02643  * @deprecated Provided for backward compatibility with the 1.0 API.
02644  */
02645 svn_error_t *svn_wc_get_diff_editor (svn_wc_adm_access_t *anchor,
02646                                      const char *target,
02647                                      const svn_wc_diff_callbacks_t *callbacks,
02648                                      void *callback_baton,
02649                                      svn_boolean_t recurse,
02650                                      svn_boolean_t use_text_base,
02651                                      svn_boolean_t reverse_order,
02652                                      svn_cancel_func_t cancel_func,
02653                                      void *cancel_baton,
02654                                      const svn_delta_editor_t **editor,
02655                                      void **edit_baton,
02656                                      apr_pool_t *pool);
02657 
02658 
02659 /**
02660  * Compare working copy against the text-base.
02661  *
02662  * @a anchor/@a target represent the base of the hierarchy to be compared.
02663  *
02664  * @a callbacks/@a callback_baton is the callback table to use when two
02665  * files are to be compared.
02666  *
02667  * @a recurse determines whether to descend into subdirectories when @a target
02668  * is a directory.  If @a recurse is @c TRUE then @a anchor should be part of 
02669  * an access baton set for the @a target hierarchy.
02670  *
02671  * @a ignore_ancestry determines whether paths that have discontinuous node
02672  * ancestry are treated as delete/add or as simple modifications.  If
02673  * @a ignore_ancestry is @c FALSE, then any discontinuous node ancestry will
02674  * result in the diff given as a full delete followed by an add.
02675  *
02676  * @since New in 1.2.
02677  */
02678 svn_error_t *svn_wc_diff3 (svn_wc_adm_access_t *anchor,
02679                            const char *target,
02680                            const svn_wc_diff_callbacks2_t *callbacks,
02681                            void *callback_baton,
02682                            svn_boolean_t recurse,
02683                            svn_boolean_t ignore_ancestry,
02684                            apr_pool_t *pool);
02685 
02686 /**
02687  * Similar to svn_wc_diff3(), but with a @c svn_wc_diff_callbacks_t argument
02688  * instead of @c svn_wc_diff_callbacks2_t.
02689  *
02690  * @deprecated Provided for backward compatibility with the 1.1 API.
02691  */
02692 svn_error_t *svn_wc_diff2 (svn_wc_adm_access_t *anchor,
02693                            const char *target,
02694                            const svn_wc_diff_callbacks_t *callbacks,
02695                            void *callback_baton,
02696                            svn_boolean_t recurse,
02697                            svn_boolean_t ignore_ancestry,
02698                            apr_pool_t *pool);
02699 
02700 /**
02701  * Similar to svn_wc_diff2(), but with @a ignore_ancestry always set
02702  * to @c FALSE.
02703  *
02704  * @deprecated Provided for backward compatibility with the 1.0 API.
02705  */
02706 svn_error_t *svn_wc_diff (svn_wc_adm_access_t *anchor,
02707                           const char *target,
02708                           const svn_wc_diff_callbacks_t *callbacks,
02709                           void *callback_baton,
02710                           svn_boolean_t recurse,
02711                           apr_pool_t *pool);
02712 
02713 
02714 /** Given a @a path to a file or directory under version control, discover
02715  * any local changes made to properties and/or the set of 'pristine'
02716  * properties.  @a adm_access is an access baton set for @a path.
02717  *
02718  * If @a propchanges is non-@c NULL, return these changes as an array of
02719  * @c svn_prop_t structures stored in @a *propchanges.  The structures and
02720  * array will be allocated in @a pool.  If there are no local property
02721  * modifications on @a path, then set @a *propchanges to @c NULL.
02722  *
02723  * If @a original_props is non-@c NULL, then set @a *original_props to
02724  * hashtable (<tt>const char *name</tt> -> <tt>const svn_string_t *value</tt>)
02725  * that represents the 'pristine' property list of @a path.  This hashtable is
02726  * allocated in @a pool, and can be used to compare old and new values of
02727  * properties.
02728  */
02729 svn_error_t *svn_wc_get_prop_diffs (apr_array_header_t **propchanges,
02730                                     apr_hash_t **original_props,
02731                                     const char *path,
02732                                     svn_wc_adm_access_t *adm_access,
02733                                     apr_pool_t *pool);
02734 
02735 
02736 /** The outcome of a merge carried out (or tried as a dry-run) by 
02737  * svn_wc_merge()
02738  */
02739 typedef enum svn_wc_merge_outcome_t
02740 {
02741    /** The working copy is (or would be) unchanged.  The changes to be
02742     * merged were already present in the working copy
02743     */
02744    svn_wc_merge_unchanged,
02745 
02746    /** The working copy has been (or would be) changed. */
02747    svn_wc_merge_merged,
02748 
02749    /** The working copy has been (or would be) changed, but there was (or
02750     * would be) a conflict
02751     */
02752    svn_wc_merge_conflict,
02753 
02754    /** No merge was performed, probably because the target file was
02755     * either absent or not under version control.
02756     */
02757    svn_wc_merge_no_merge
02758 
02759 } svn_wc_merge_outcome_t;
02760 
02761 /** Given paths to three fulltexts, merge the differences between @a left
02762  * and @a right into @a merge_target.  (It may help to know that @a left,
02763  * @a right, and @a merge_target correspond to "OLDER", "YOURS", and "MINE",
02764  * respectively, in the diff3 documentation.)  Use @a pool for any
02765  * temporary allocation.
02766  *
02767  * @a adm_access is an access baton with a write lock for the directory
02768  * containing @a merge_target.
02769  *
02770  * This function assumes that @a left and @a right are in repository-normal
02771  * form (linefeeds, with keywords contracted); if necessary,
02772  * @a merge_target is temporarily converted to this form to receive the
02773  * changes, then translated back again.
02774  *
02775  * If @a merge_target is absent, or present but not under version
02776  * control, then set @a *merge_outcome to @c svn_wc_merge_no_merge and
02777  * return success without merging anything.  (The reasoning is that if
02778  * the file is not versioned, then it is probably unrelated to the
02779  * changes being considered, so they should not be merged into it.)
02780  *
02781  * @a dry_run determines whether the working copy is modified.  When it
02782  * is @c FALSE the merge will cause @a merge_target to be modified, when it
02783  * is @c TRUE the merge will be carried out to determine the result but
02784  * @a merge_target will not be modified.
02785  *
02786  * If @a diff3_cmd is non-null, then use it as the diff3 command for
02787  * any merging; otherwise, use the built-in merge code.
02788  *
02789  * The outcome of the merge is returned in @a *merge_outcome. If there is
02790  * a conflict and @a dry_run is @c FALSE, then
02791  *
02792  *   * Put conflict markers around the conflicting regions in
02793  *     @a merge_target, labeled with @a left_label, @a right_label, and
02794  *     @a target_label.  (If any of these labels are @c NULL, default 
02795  *     values will be used.)
02796  * 
02797  *   * Copy @a left, @a right, and the original @a merge_target to unique 
02798  *     names in the same directory as @a merge_target, ending with the 
02799  *     suffixes ".LEFT_LABEL", ".RIGHT_LABEL", and ".TARGET_LABEL"
02800  *     respectively.
02801  *
02802  *   * Mark the entry for @a merge_target as "conflicted", and track the
02803  *     above mentioned backup files in the entry as well.
02804  *
02805  * Binary case:
02806  *
02807  *  If @a merge_target is a binary file, then no merging is attempted,
02808  *  the merge is deemed to be a conflict.  If @a dry_run is @c FALSE the
02809  *  working @a merge_target is untouched, and copies of @a left and 
02810  *  @a right are created next to it using @a left_label and @a right_label.
02811  *  @a merge_target's entry is marked as "conflicted", and begins
02812  *  tracking the two backup files.  If @a dry_run is @c TRUE no files are
02813  *  changed.  The outcome of the merge is returned in @a *merge_outcome.
02814  */
02815 svn_error_t *svn_wc_merge (const char *left,
02816                            const char *right,
02817                            const char *merge_target,
02818                            svn_wc_adm_access_t *adm_access,
02819                            const char *left_label,
02820                            const char *right_label,
02821                            const char *target_label,
02822                            svn_boolean_t dry_run,
02823                            enum svn_wc_merge_outcome_t *merge_outcome,
02824                            const char *diff3_cmd,
02825                            apr_pool_t *pool);
02826 
02827 
02828 /** Given a @a path under version control, merge an array of @a
02829  * propchanges into the path's existing properties.  @a propchanges is
02830  * an array of @c svn_prop_t objects, and @a baseprops is a hash
02831  * representing the original set of properties that @a propchanges is
02832  * working against.  @a adm_access is an access baton for the directory
02833  * containing @a path.
02834  *
02835  * If @a base_merge is @c FALSE only the working properties will be changed,
02836  * if it is @c TRUE both the base and working properties will be changed.
02837  *
02838  * If @a state is non-null, set @a *state to the state of the properties
02839  * after the merge.
02840  *
02841  * If conflicts are found when merging working properties, they are
02842  * described in a temporary .prej file (or appended to an already-existing
02843  * .prej file), and the entry is marked "conflicted".  Base properties
02844  * are changed unconditionally, if @a base_merge is @c TRUE, they never result
02845  * in a conflict.
02846  *
02847  * If @a path is not under version control, return the error
02848  * SVN_ERR_UNVERSIONED_RESOURCE and don't touch anyone's properties.
02849  *
02850  * @since New in 1.3.
02851  */
02852 svn_error_t *
02853 svn_wc_merge_props (svn_wc_notify_state_t *state,
02854                     const char *path,
02855                     svn_wc_adm_access_t *adm_access,
02856                     apr_hash_t *baseprops,
02857                     const apr_array_header_t *propchanges,
02858                     svn_boolean_t base_merge,
02859                     svn_boolean_t dry_run,
02860                     apr_pool_t *pool);
02861 
02862 
02863 /** 
02864  * Similar to svn_wc_merge_props(), but no baseprops are given.
02865  * Instead, it's assumed that the incoming propchanges are based
02866  * against the working copy's own baseprops.  While this assumption is
02867  * correct for 'svn update', it's incorrect for 'svn merge', and can
02868  * cause flawed behavior.  (See issue #2035.)
02869  *
02870  * @deprecated Provided for backward compatibility with the 1.2 API.
02871  */
02872 svn_error_t *
02873 svn_wc_merge_prop_diffs (svn_wc_notify_state_t *state,
02874                          const char *path,
02875                          svn_wc_adm_access_t *adm_access,
02876                          const apr_array_header_t *propchanges,
02877                          svn_boolean_t base_merge,
02878                          svn_boolean_t dry_run,
02879                          apr_pool_t *pool);
02880 
02881 
02882 
02883 /** Given a @a path to a wc file, return a @a pristine_path which points to a
02884  * pristine version of the file.  This is needed so clients can do
02885  * diffs.  If the WC has no text-base, return a @c NULL instead of a
02886  * path.
02887  */
02888 svn_error_t *svn_wc_get_pristine_copy_path (const char *path,
02889                                             const char **pristine_path,
02890                                             apr_pool_t *pool);
02891 
02892 
02893 /**
02894  * Recurse from @a path, cleaning up unfinished log business.  Perform
02895  * necessary allocations in @a pool.  Any working copy locks under @a path 
02896  * will be taken over and then cleared by this function.  If @a diff3_cmd
02897  * is non-null, then use it as the diff3 command for any merging; otherwise,
02898  * use the built-in merge code.
02899  *
02900  * WARNING: there is no mechanism that will protect locks that are still 
02901  * being used.
02902  *
02903  * If @a cancel_func is non-null, invoke it with @a cancel_baton at
02904  * various points during the operation.  If it returns an error
02905  * (typically @c SVN_ERR_CANCELLED), return that error immediately.
02906  *
02907  * @since New in 1.2.
02908  */
02909 svn_error_t *
02910 svn_wc_cleanup2 (const char *path,
02911                  const char *diff3_cmd,
02912                  svn_cancel_func_t cancel_func,
02913                  void *cancel_baton,
02914                  apr_pool_t *pool);
02915 
02916 /**
02917  * Similar to svn_wc_cleanup2(). @a optional_adm_access is an historic
02918  * relic and not used, it may be NULL.
02919  *
02920  * @deprecated Provided for backward compatibility with the 1.1 API.
02921  */
02922 svn_error_t *
02923 svn_wc_cleanup (const char *path,
02924                 svn_wc_adm_access_t *optional_adm_access,
02925                 const char *diff3_cmd,
02926                 svn_cancel_func_t cancel_func,
02927                 void *cancel_baton,
02928                 apr_pool_t *pool);
02929 
02930 
02931 /** Relocation validation callback typedef.
02932  *
02933  * Called for each relocated file/directory.  @a uuid contains the
02934  * expected repository UUID, @a url contains the tentative URL.
02935  *
02936  * @a baton is a closure object; it should be provided by the
02937  * implementation, and passed by the caller.
02938  */
02939 typedef svn_error_t *(*svn_wc_relocation_validator_t) (void *baton,
02940                                                        const char *uuid,
02941                                                        const char *url);
02942 
02943 
02944 /** Change repository references at @a path that begin with @a from
02945  * to begin with @a to instead.  Perform necessary allocations in @a pool. 
02946  * If @a recurse is true, do so.  @a validator (and its baton,
02947  * @a validator_baton), will be called for each newly generated URL.
02948  *
02949  * @a adm_access is an access baton for the directory containing
02950  * @a path.
02951  */
02952 svn_error_t *
02953 svn_wc_relocate (const char *path,
02954                  svn_wc_adm_access_t *adm_access,
02955                  const char *from,
02956                  const char *to,
02957                  svn_boolean_t recurse,
02958                  svn_wc_relocation_validator_t validator,
02959                  void *validator_baton,
02960                  apr_pool_t *pool);
02961 
02962 
02963 /**
02964  * Revert changes to @a path (perhaps in a @a recursive fashion).  Perform
02965  * necessary allocations in @a pool.
02966  *
02967  * @a parent_access is an access baton for the directory containing @a path,
02968  * unless @a path is a wc root, in which case @a parent_access refers to 
02969  * @a path itself.
02970  *
02971  * If @a cancel_func is non-null, call it with @a cancel_baton at
02972  * various points during the reversion process.  If it returns an
02973  * error (typically @c SVN_ERR_CANCELLED), return that error
02974  * immediately.
02975  *
02976  * If @a use_commit_times is TRUE, then all reverted working-files
02977  * will have their timestamp set to the last-committed-time.  If
02978  * FALSE, the reverted working-files will be touched with the 'now' time.
02979  *
02980  * For each item reverted, @a notify_func will be called with @a notify_baton
02981  * and the path of the reverted item. @a notify_func may be @c NULL if this
02982  * notification is not needed.
02983  *
02984  * If @a path is not under version control, return the error
02985  * SVN_ERR_UNVERSIONED_RESOURCE.
02986  *
02987  * @since New in 1.2.
02988  */
02989 svn_error_t *
02990 svn_wc_revert2 (const char *path, 
02991                 svn_wc_adm_access_t *parent_access,
02992                 svn_boolean_t recursive, 
02993                 svn_boolean_t use_commit_times,
02994                 svn_cancel_func_t cancel_func,
02995                 void *cancel_baton,
02996                 svn_wc_notify_func2_t notify_func,
02997                 void *notify_baton,
02998                 apr_pool_t *pool);
02999 
03000 /**
03001  * Similar to svn_wc_revert2(), but takes an @c svn_wc_notify_func_t instead.
03002  *
03003  * @deprecated Provided for backward compatibility with the 1.1 API.
03004  */
03005 svn_error_t *
03006 svn_wc_revert (const char *path, 
03007                svn_wc_adm_access_t *parent_access,
03008                svn_boolean_t recursive, 
03009                svn_boolean_t use_commit_times,
03010                svn_cancel_func_t cancel_func,
03011                void *cancel_baton,
03012                svn_wc_notify_func_t notify_func,
03013                void *notify_baton,
03014                apr_pool_t *pool);
03015 
03016 
03017 /* Tmp files */
03018 
03019 /** Create a unique temporary file in administrative tmp/ area of
03020  * directory @a path.  Return a handle in @a *fp.
03021  *
03022  * The flags will be <tt>APR_WRITE | APR_CREATE | APR_EXCL</tt> and
03023  * optionally @c APR_DELONCLOSE (if the @a delete_on_close argument is 
03024  * set @c TRUE).
03025  *
03026  * This means that as soon as @a fp is closed, the tmp file will vanish.
03027  */
03028 svn_error_t *
03029 svn_wc_create_tmp_file (apr_file_t **fp,
03030                         const char *path,
03031                         svn_boolean_t delete_on_close,
03032                         apr_pool_t *pool);
03033 
03034 
03035 
03036 /* EOL conversion and keyword expansion. */
03037 
03038 /** Set @a *xlated_p to a path to a possibly translated copy of versioned
03039  * file @a vfile, or to @a vfile itself if no translation is necessary.
03040  * That is, if @a vfile's properties indicate newline conversion or
03041  * keyword expansion, point @a *xlated_p to a copy of @a vfile whose
03042  * newlines are unconverted and keywords contracted, in whatever
03043  * manner is indicated by @a vfile's properties; otherwise, set @a *xlated_p
03044  * to @a vfile.
03045  *
03046  * If @a force_repair is set, the translated file will have any
03047  * inconsistent line endings repaired.  This should only be used when
03048  * the resultant file is being created for comparison against @a vfile's
03049  * text base.
03050  *
03051  * Caller is responsible for detecting if they are different (pointer
03052  * comparison is sufficient), and for removing @a *xlated_p if
03053  * necessary.
03054  *
03055  * This function is generally used to get a file that can be compared
03056  * meaningfully against @a vfile's text base.
03057  *
03058  * If @a *xlated_p is different from @a vfile, then choose @a *xlated_p's 
03059  * name using svn_io_open_unique_file() with @c SVN_WC__TMP_EXT, and 
03060  * allocate it in @a pool.  Also use @a pool for any temporary allocation.
03061  *
03062  * If an error is returned, the effect on @a *xlated_p is undefined.
03063  */
03064 svn_error_t *svn_wc_translated_file (const char **xlated_p,
03065                                      const char *vfile,
03066                                      svn_wc_adm_access_t *adm_access,
03067                                      svn_boolean_t force_repair,
03068                                      apr_pool_t *pool);
03069 
03070 
03071 
03072 /* Text/Prop Deltas Using an Editor */
03073 
03074 
03075 /** Send the local modifications for versioned file @a path (with
03076  * matching @a file_baton) through @a editor, then close @a file_baton
03077  * afterwards.  Use @a pool for any temporary allocation and
03078  * @a adm_access as an access baton for @a path.
03079  * 
03080  * This process creates a copy of @a path with keywords and eol
03081  * untranslated.  If @a tempfile is non-null, set @a *tempfile to the 
03082  * path to this copy.  Do not clean up the copy; caller can do that.  
03083  * (The purpose of handing back the tmp copy is that it is usually about 
03084  * to become the new text base anyway, but the installation of the new
03085  * text base is outside the scope of this function.)
03086  *
03087  * If @a fulltext, send the untranslated copy of @a path through @a editor 
03088  * as full-text; else send it as svndiff against the current text base.
03089  *
03090  * If sending a diff, and the recorded checksum for @a path's text-base
03091  * does not match the current actual checksum, then remove the tmp
03092  * copy (and set @a *tempfile to null if appropriate), and return the
03093  * error @c SVN_ERR_WC_CORRUPT_TEXT_BASE.
03094  *
03095  * @note This is intended for use with both infix and postfix
03096  * text-delta styled editor drivers.
03097  */
03098 svn_error_t *svn_wc_transmit_text_deltas (const char *path,
03099                                           svn_wc_adm_access_t *adm_access,
03100                                           svn_boolean_t fulltext,
03101                                           const svn_delta_editor_t *editor,
03102                                           void *file_baton,
03103                                           const char **tempfile,
03104                                           apr_pool_t *pool);
03105 
03106 
03107 /** Given a @a path with its accompanying @a entry, transmit all local 
03108  * property modifications using the appropriate @a editor method (in 
03109  * conjunction with @a baton). @a adm_access is an access baton set
03110  * that contains @a path.  Use @a pool for all allocations.
03111  *
03112  * If a temporary file remains after this function is finished, the
03113  * path to that file is returned in @a *tempfile (so the caller can 
03114  * clean this up if it wishes to do so).
03115  */
03116 svn_error_t *svn_wc_transmit_prop_deltas (const char *path,
03117                                           svn_wc_adm_access_t *adm_access,
03118                                           const svn_wc_entry_t *entry,
03119                                           const svn_delta_editor_t *editor,
03120                                           void *baton,
03121                                           const char **tempfile,
03122                                           apr_pool_t *pool);
03123 
03124 
03125 /** Get the run-time configured list of ignore patterns from the 
03126  * @c svn_config_t's in the @a config hash, and store them in @a *patterns.
03127  * Allocate @a *patterns and its contents in @a pool.
03128  */
03129 svn_error_t *svn_wc_get_default_ignores (apr_array_header_t **patterns,
03130                                          apr_hash_t *config,
03131                                          apr_pool_t *pool);
03132 
03133 /** Get the list of ignore patterns from the @c svn_config_t's in the 
03134  * @a config hash and the local ignore patterns from the directory
03135  * in @a adm_access, and store them in @a *patterns.
03136  * Allocate @a *patterns and its contents in @a pool.
03137  *
03138  * @since New in 1.3.
03139  */
03140 svn_error_t *svn_wc_get_ignores (apr_array_header_t **patterns,
03141                                  apr_hash_t *config,
03142                                  svn_wc_adm_access_t *adm_access,
03143                                  apr_pool_t *pool);
03144 
03145 
03146 /** Add @a lock to the working copy for @a path.  @a adm_access must contain
03147  * a write lock for @a path.  If @a path is read-only, due to locking
03148  * properties, make it writable.  Perform temporary allocations in @a
03149  * pool. */
03150 svn_error_t *svn_wc_add_lock (const char *path, const svn_lock_t *lock,
03151                               svn_wc_adm_access_t *adm_access,
03152                               apr_pool_t *pool);
03153 
03154 /** Remove any lock from @a path.  @a adm_access must contain a
03155  * write-lock for @a path.  If @a path has a lock and the locking
03156  * so specifies, make the file read-only.  Don't return an error if @a
03157  * path didn't have a lock.  Perform temporary allocations in @a pool. */
03158 svn_error_t *svn_wc_remove_lock (const char *path,
03159                                  svn_wc_adm_access_t *adm_access,
03160                                  apr_pool_t *pool);
03161 
03162 
03163 #ifdef __cplusplus
03164 }
03165 #endif /* __cplusplus */
03166 
03167 #endif  /* SVN_WC_H */

Generated on Tue May 9 12:43:01 2006 for Subversion by  doxygen 1.4.6