1/** 2 * @copyright 3 * ==================================================================== 4 * Licensed to the Apache Software Foundation (ASF) under one 5 * or more contributor license agreements. See the NOTICE file 6 * distributed with this work for additional information 7 * regarding copyright ownership. The ASF licenses this file 8 * to you under the Apache License, Version 2.0 (the 9 * "License"); you may not use this file except in compliance 10 * with the License. You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, 15 * software distributed under the License is distributed on an 16 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 17 * KIND, either express or implied. See the License for the 18 * specific language governing permissions and limitations 19 * under the License. 20 * ==================================================================== 21 * @endcopyright 22 * 23 * @file svn_wc.h 24 * @brief Subversion's working copy library 25 * 26 * Requires: 27 * - A working copy 28 * 29 * Provides: 30 * - Ability to manipulate working copy's versioned data. 31 * - Ability to manipulate working copy's administrative files. 32 * 33 * Used By: 34 * - Clients. 35 * 36 * Notes: 37 * The 'path' parameters to most of the older functions can be 38 * absolute or relative (relative to current working 39 * directory). If there are any cases where they are 40 * relative to the path associated with the 41 * 'svn_wc_adm_access_t *adm_access' baton passed along with the 42 * path, those cases should be explicitly documented, and if they 43 * are not, please fix it. All new functions introduced since 44 * Subversion 1.7 require absolute paths, unless explicitly 45 * documented otherwise. 46 * 47 * Starting with Subversion 1.7, several arguments are re-ordered 48 * to be more consistent through the api. The common ordering used 49 * is: 50 * 51 * Firsts: 52 * - Output arguments 53 * Then: 54 * - Working copy context 55 * - Local abspath 56 * Followed by: 57 * - Function specific arguments 58 * - Specific callbacks with their batons 59 * Finally: 60 * - Generic callbacks (with baton) from directly functional to 61 * just observing: 62 * - svn_wc_conflict_resolver_func2_t 63 * - svn_wc_external_update_t 64 * - svn_cancel_func_t 65 * - svn_wc_notify_func2_t 66 * - Result pool 67 * - Scratch pool. 68 */ 69 70#ifndef SVN_WC_H 71#define SVN_WC_H 72 73#include <apr.h> 74#include <apr_pools.h> 75#include <apr_tables.h> 76#include <apr_hash.h> 77#include <apr_time.h> 78#include <apr_file_io.h> 79 80#include "svn_types.h" 81#include "svn_string.h" 82#include "svn_checksum.h" 83#include "svn_io.h" 84#include "svn_delta.h" /* for svn_stream_t */ 85#include "svn_opt.h" 86#include "svn_ra.h" /* for svn_ra_reporter_t type */ 87 88#ifdef __cplusplus 89extern "C" { 90#endif /* __cplusplus */ 91 92 93/** 94 * Get libsvn_wc version information. 95 * 96 * @since New in 1.1. 97 */ 98const svn_version_t * 99svn_wc_version(void); 100 101 102/** 103 * @defgroup svn_wc Working copy management 104 * @{ 105 */ 106 107 108/** Flags for use with svn_wc_translated_file2() and svn_wc_translated_stream(). 109 * 110 * @defgroup translate_flags Translation flags 111 * @{ 112 */ 113 114 /** Translate from Normal Form. 115 * 116 * The working copy text bases and repository files are stored 117 * in normal form. Some files' contents - or ever representation - 118 * differs between the working copy and the normal form. This flag 119 * specifies to take the latter form as input and transform it 120 * to the former. 121 * 122 * Either this flag or #SVN_WC_TRANSLATE_TO_NF should be specified, 123 * but not both. 124 */ 125#define SVN_WC_TRANSLATE_FROM_NF 0x00000000 126 127 /** Translate to Normal Form. 128 * 129 * Either this flag or #SVN_WC_TRANSLATE_FROM_NF should be specified, 130 * but not both. 131 */ 132#define SVN_WC_TRANSLATE_TO_NF 0x00000001 133 134 /** Force repair of eol styles, making sure the output file consistently 135 * contains the one eol style as specified by the svn:eol-style 136 * property and the required translation direction. 137 * 138 */ 139#define SVN_WC_TRANSLATE_FORCE_EOL_REPAIR 0x00000002 140 141 /** Don't register a pool cleanup to delete the output file */ 142#define SVN_WC_TRANSLATE_NO_OUTPUT_CLEANUP 0x00000004 143 144 /** Guarantee a new file is created on successful return. 145 * The default shortcuts translation by returning the path 146 * of the untranslated file when no translation is required. 147 */ 148#define SVN_WC_TRANSLATE_FORCE_COPY 0x00000008 149 150 /** Use a non-wc-local tmp directory for creating output files, 151 * instead of in the working copy admin tmp area which is the default. 152 * 153 * @since New in 1.4. 154 */ 155#define SVN_WC_TRANSLATE_USE_GLOBAL_TMP 0x00000010 156 157/** @} */ 158 159 160/** 161 * @defgroup svn_wc_context Working copy context 162 * @{ 163 */ 164 165/** The context for all working copy interactions. 166 * 167 * This is the client-facing datastructure API consumers are required 168 * to create and use when interacting with a working copy. Multiple 169 * contexts can be created for the same working copy simultaneously, within 170 * the same process or different processes. Context mutexing will be handled 171 * internally by the working copy library. 172 * 173 * @note: #svn_wc_context_t should be passed by non-const pointer in all 174 * APIs, even for read-only operations, as it contains mutable data (caching, 175 * etc.). 176 * 177 * @since New in 1.7. 178 */ 179typedef struct svn_wc_context_t svn_wc_context_t; 180 181/** Create a context for the working copy, and return it in @a *wc_ctx. This 182 * context is not associated with a particular working copy, but as operations 183 * are performed, will load the appropriate working copy information. 184 * 185 * @a config should hold the various configuration options that may apply to 186 * this context. It should live at least as long as @a result_pool. It may 187 * be @c NULL. 188 * 189 * The context will be allocated in @a result_pool, and will use @a 190 * result_pool for any internal allocations requiring the same longevity as 191 * the context. The context will be automatically destroyed, and its 192 * resources released, when @a result_pool is cleared, or it may be manually 193 * destroyed by invoking svn_wc_context_destroy(). 194 * 195 * Use @a scratch_pool for temporary allocations. It may be cleared 196 * immediately upon returning from this function. 197 * 198 * @since New in 1.7. 199 */ 200svn_error_t * 201svn_wc_context_create(svn_wc_context_t **wc_ctx, 202 const svn_config_t *config, 203 apr_pool_t *result_pool, 204 apr_pool_t *scratch_pool); 205 206 207/** Destroy the working copy context described by @a wc_ctx, releasing any 208 * acquired resources. 209 * 210 * @since New in 1.7. 211 */ 212svn_error_t * 213svn_wc_context_destroy(svn_wc_context_t *wc_ctx); 214 215 216/** @} */ 217 218 219/** 220 * Locking/Opening/Closing using adm access batons. 221 * 222 * @defgroup svn_wc_adm_access Adm access batons (deprecated) 223 * @{ 224 */ 225 226/** Baton for access to a working copy administrative area. 227 * 228 * Access batons can be grouped into sets, by passing an existing open 229 * baton when opening a new baton. Given one baton in a set, other batons 230 * may be retrieved. This allows an entire hierarchy to be locked, and 231 * then the set of batons can be passed around by passing a single baton. 232 * 233 * @deprecated Provided for backward compatibility with the 1.6 API. 234 * New code should use a #svn_wc_context_t object to access the working 235 * copy. 236 */ 237typedef struct svn_wc_adm_access_t svn_wc_adm_access_t; 238 239 240/** 241 * Return, in @a *adm_access, a pointer to a new access baton for the working 242 * copy administrative area associated with the directory @a path. If 243 * @a write_lock is TRUE the baton will include a write lock, otherwise the 244 * baton can only be used for read access. If @a path refers to a directory 245 * that is already write locked then the error #SVN_ERR_WC_LOCKED will be 246 * returned. The error #SVN_ERR_WC_NOT_DIRECTORY will be returned if 247 * @a path is not a versioned directory. 248 * 249 * If @a associated is an open access baton then @a adm_access will be added 250 * to the set containing @a associated. @a associated can be @c NULL, in 251 * which case @a adm_access is the start of a new set. 252 * 253 * @a levels_to_lock specifies how far to lock. Zero means just the specified 254 * directory. Any negative value means to lock the entire working copy 255 * directory hierarchy under @a path. A positive value indicates the number of 256 * levels of directories to lock -- 1 means just immediate subdirectories, 2 257 * means immediate subdirectories and their subdirectories, etc. All the 258 * access batons will become part of the set containing @a adm_access. This 259 * is an all-or-nothing option, if it is not possible to lock all the 260 * requested directories then an error will be returned and @a adm_access will 261 * be invalid, with the exception that subdirectories of @a path that are 262 * missing from the physical filesystem will not be locked and will not cause 263 * an error. The error #SVN_ERR_WC_LOCKED will be returned if a 264 * subdirectory of @a path is already write locked. 265 * 266 * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine 267 * if the client has canceled the operation. 268 * 269 * @a pool will be used to allocate memory for the baton and any subsequently 270 * cached items. If @a adm_access has not been closed when the pool is 271 * cleared, it will be closed automatically at that point, and removed from 272 * its set. A baton closed in this way will not remove physical locks from 273 * the working copy if cleanup is required. 274 * 275 * The first baton in a set, with @a associated passed as @c NULL, must have 276 * the longest lifetime of all the batons in the set. This implies it must be 277 * the root of the hierarchy. 278 * 279 * @since New in 1.2. 280 * @deprecated Provided for backward compatibility with the 1.6 API. 281 * Callers should use a #svn_wc_context_t object to access the working 282 * copy. 283 */ 284SVN_DEPRECATED 285svn_error_t * 286svn_wc_adm_open3(svn_wc_adm_access_t **adm_access, 287 svn_wc_adm_access_t *associated, 288 const char *path, 289 svn_boolean_t write_lock, 290 int levels_to_lock, 291 svn_cancel_func_t cancel_func, 292 void *cancel_baton, 293 apr_pool_t *pool); 294 295/** 296 * Similar to svn_wc_adm_open3(), but without cancellation support. 297 * 298 * @deprecated Provided for backward compatibility with the 1.1 API. 299 */ 300SVN_DEPRECATED 301svn_error_t * 302svn_wc_adm_open2(svn_wc_adm_access_t **adm_access, 303 svn_wc_adm_access_t *associated, 304 const char *path, 305 svn_boolean_t write_lock, 306 int levels_to_lock, 307 apr_pool_t *pool); 308 309/** 310 * Similar to svn_wc_adm_open2(), but with @a tree_lock instead of 311 * @a levels_to_lock. @a levels_to_lock is set to -1 if @a tree_lock 312 * is @c TRUE, else 0. 313 * 314 * @deprecated Provided for backward compatibility with the 1.0 API. 315 */ 316SVN_DEPRECATED 317svn_error_t * 318svn_wc_adm_open(svn_wc_adm_access_t **adm_access, 319 svn_wc_adm_access_t *associated, 320 const char *path, 321 svn_boolean_t write_lock, 322 svn_boolean_t tree_lock, 323 apr_pool_t *pool); 324 325/** 326 * Checks the working copy to determine the node type of @a path. If 327 * @a path is a versioned directory then the behaviour is like that of 328 * svn_wc_adm_open3(), otherwise, if @a path is a file or does not 329 * exist, then the behaviour is like that of svn_wc_adm_open3() with 330 * @a path replaced by the parent directory of @a path. If @a path is 331 * an unversioned directory, the behaviour is also like that of 332 * svn_wc_adm_open3() on the parent, except that if the open fails, 333 * then the returned #SVN_ERR_WC_NOT_DIRECTORY error refers to @a path, 334 * not to @a path's parent. 335 * 336 * @since New in 1.2. 337 * @deprecated Provided for backward compatibility with the 1.6 API. 338 * Callers should use a #svn_wc_context_t object to access the working 339 * copy. 340 */ 341SVN_DEPRECATED 342svn_error_t * 343svn_wc_adm_probe_open3(svn_wc_adm_access_t **adm_access, 344 svn_wc_adm_access_t *associated, 345 const char *path, 346 svn_boolean_t write_lock, 347 int levels_to_lock, 348 svn_cancel_func_t cancel_func, 349 void *cancel_baton, 350 apr_pool_t *pool); 351 352/** 353 * Similar to svn_wc_adm_probe_open3() without the cancel 354 * functionality. 355 * 356 * @deprecated Provided for backward compatibility with the 1.1 API. 357 */ 358SVN_DEPRECATED 359svn_error_t * 360svn_wc_adm_probe_open2(svn_wc_adm_access_t **adm_access, 361 svn_wc_adm_access_t *associated, 362 const char *path, 363 svn_boolean_t write_lock, 364 int levels_to_lock, 365 apr_pool_t *pool); 366 367/** 368 * Similar to svn_wc_adm_probe_open2(), but with @a tree_lock instead of 369 * @a levels_to_lock. @a levels_to_lock is set to -1 if @a tree_lock 370 * is @c TRUE, else 0. 371 * 372 * @deprecated Provided for backward compatibility with the 1.0 API. 373 */ 374SVN_DEPRECATED 375svn_error_t * 376svn_wc_adm_probe_open(svn_wc_adm_access_t **adm_access, 377 svn_wc_adm_access_t *associated, 378 const char *path, 379 svn_boolean_t write_lock, 380 svn_boolean_t tree_lock, 381 apr_pool_t *pool); 382 383/** 384 * Open access batons for @a path and return in @a *anchor_access and 385 * @a *target the anchor and target required to drive an editor. Return 386 * in @a *target_access the access baton for the target, which may be the 387 * same as @a *anchor_access (in which case @a *target is the empty 388 * string, never NULL). All the access batons will be in the 389 * @a *anchor_access set. 390 * 391 * @a levels_to_lock determines the levels_to_lock used when opening 392 * @a path if @a path is a versioned directory, @a levels_to_lock is 393 * ignored otherwise. If @a write_lock is @c TRUE the access batons 394 * will hold write locks. 395 * 396 * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine 397 * if the client has canceled the operation. 398 * 399 * This function is essentially a combination of svn_wc_adm_open3() and 400 * svn_wc_get_actual_target(), with the emphasis on reducing physical IO. 401 * 402 * @since New in 1.2. 403 * @deprecated Provided for backward compatibility with the 1.6 API. 404 * Callers should use a #svn_wc_context_t object to access the working 405 * copy. 406 */ 407SVN_DEPRECATED 408svn_error_t * 409svn_wc_adm_open_anchor(svn_wc_adm_access_t **anchor_access, 410 svn_wc_adm_access_t **target_access, 411 const char **target, 412 const char *path, 413 svn_boolean_t write_lock, 414 int levels_to_lock, 415 svn_cancel_func_t cancel_func, 416 void *cancel_baton, 417 apr_pool_t *pool); 418 419/** Return, in @a *adm_access, a pointer to an existing access baton associated 420 * with @a path. @a path must be a directory that is locked as part of the 421 * set containing the @a associated access baton. 422 * 423 * If the requested access baton is marked as missing in, or is simply 424 * absent from, @a associated, return #SVN_ERR_WC_NOT_LOCKED. 425 * 426 * @a pool is used only for local processing, it is not used for the batons. 427 * 428 * @deprecated Provided for backward compatibility with the 1.6 API. 429 */ 430SVN_DEPRECATED 431svn_error_t * 432svn_wc_adm_retrieve(svn_wc_adm_access_t **adm_access, 433 svn_wc_adm_access_t *associated, 434 const char *path, 435 apr_pool_t *pool); 436 437/** Check the working copy to determine the node type of @a path. If 438 * @a path is a versioned directory then the behaviour is like that of 439 * svn_wc_adm_retrieve(), otherwise, if @a path is a file, an unversioned 440 * directory, or does not exist, then the behaviour is like that of 441 * svn_wc_adm_retrieve() with @a path replaced by the parent directory of 442 * @a path. 443 * 444 * @deprecated Provided for backward compatibility with the 1.6 API. 445 */ 446SVN_DEPRECATED 447svn_error_t * 448svn_wc_adm_probe_retrieve(svn_wc_adm_access_t **adm_access, 449 svn_wc_adm_access_t *associated, 450 const char *path, 451 apr_pool_t *pool); 452 453/** 454 * Try various ways to obtain an access baton for @a path. 455 * 456 * First, try to obtain @a *adm_access via svn_wc_adm_probe_retrieve(), 457 * but if this fails because @a associated can't give a baton for 458 * @a path or @a path's parent, then try svn_wc_adm_probe_open3(), 459 * this time passing @a write_lock and @a levels_to_lock. If there is 460 * still no access because @a path is not a versioned directory, then 461 * just set @a *adm_access to NULL and return success. But if it is 462 * because @a path is locked, then return the error #SVN_ERR_WC_LOCKED, 463 * and the effect on @a *adm_access is undefined. (Or if the attempt 464 * fails for any other reason, return the corresponding error, and the 465 * effect on @a *adm_access is also undefined.) 466 * 467 * If svn_wc_adm_probe_open3() succeeds, then add @a *adm_access to 468 * @a associated. 469 * 470 * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine 471 * if the client has canceled the operation. 472 * 473 * Use @a pool only for local processing, not to allocate @a *adm_access. 474 * 475 * @since New in 1.2. 476 * @deprecated Provided for backward compatibility with the 1.6 API. 477 */ 478SVN_DEPRECATED 479svn_error_t * 480svn_wc_adm_probe_try3(svn_wc_adm_access_t **adm_access, 481 svn_wc_adm_access_t *associated, 482 const char *path, 483 svn_boolean_t write_lock, 484 int levels_to_lock, 485 svn_cancel_func_t cancel_func, 486 void *cancel_baton, 487 apr_pool_t *pool); 488 489/** 490 * Similar to svn_wc_adm_probe_try3() without the cancel 491 * functionality. 492 * 493 * @deprecated Provided for backward compatibility with the 1.1 API. 494 */ 495SVN_DEPRECATED 496svn_error_t * 497svn_wc_adm_probe_try2(svn_wc_adm_access_t **adm_access, 498 svn_wc_adm_access_t *associated, 499 const char *path, 500 svn_boolean_t write_lock, 501 int levels_to_lock, 502 apr_pool_t *pool); 503 504/** 505 * Similar to svn_wc_adm_probe_try2(), but with @a tree_lock instead of 506 * @a levels_to_lock. @a levels_to_lock is set to -1 if @a tree_lock 507 * is @c TRUE, else 0. 508 * 509 * @deprecated Provided for backward compatibility with the 1.0 API. 510 */ 511SVN_DEPRECATED 512svn_error_t * 513svn_wc_adm_probe_try(svn_wc_adm_access_t **adm_access, 514 svn_wc_adm_access_t *associated, 515 const char *path, 516 svn_boolean_t write_lock, 517 svn_boolean_t tree_lock, 518 apr_pool_t *pool); 519 520 521/** Give up the access baton @a adm_access, and its lock if any. This will 522 * recursively close any batons in the same set that are direct 523 * subdirectories of @a adm_access. Any physical locks will be removed from 524 * the working copy. Lock removal is unconditional, there is no check to 525 * determine if cleanup is required. 526 * 527 * Any temporary allocations are performed using @a scratch_pool. 528 * 529 * @since New in 1.6 530 * @deprecated Provided for backward compatibility with the 1.6 API. 531 */ 532SVN_DEPRECATED 533svn_error_t * 534svn_wc_adm_close2(svn_wc_adm_access_t *adm_access, 535 apr_pool_t *scratch_pool); 536 537/** 538 * Similar to svn_wc_adm_close2(), but with the internal pool of @a adm_access 539 * used for temporary allocations. 540 * 541 * @deprecated Provided for backward compatibility with the 1.5 API. 542 */ 543SVN_DEPRECATED 544svn_error_t * 545svn_wc_adm_close(svn_wc_adm_access_t *adm_access); 546 547/** Return the path used to open the access baton @a adm_access. 548 * 549 * @deprecated Provided for backward compatibility with the 1.6 API. 550 */ 551SVN_DEPRECATED 552const char * 553svn_wc_adm_access_path(const svn_wc_adm_access_t *adm_access); 554 555/** Return the pool used by access baton @a adm_access. 556 * 557 * @deprecated Provided for backward compatibility with the 1.6 API. 558 */ 559SVN_DEPRECATED 560apr_pool_t * 561svn_wc_adm_access_pool(const svn_wc_adm_access_t *adm_access); 562 563/** Return @c TRUE is the access baton @a adm_access has a write lock, 564 * @c FALSE otherwise. Compared to svn_wc_locked() this is a cheap, fast 565 * function that doesn't access the filesystem. 566 * 567 * @deprecated Provided for backward compatibility with the 1.6 API. 568 * New code should use svn_wc_locked2() instead. 569 */ 570SVN_DEPRECATED 571svn_boolean_t 572svn_wc_adm_locked(const svn_wc_adm_access_t *adm_access); 573 574/** @} */ 575 576 577/** Gets up to two booleans indicating whether a path is locked for 578 * writing. 579 * 580 * @a locked_here is set to TRUE when a write lock on @a local_abspath 581 * exists in @a wc_ctx. @a locked is set to TRUE when there is a 582 * write_lock on @a local_abspath 583 * 584 * @a locked_here and/or @a locked can be NULL when you are not 585 * interested in a specific value 586 * 587 * @since New in 1.7. 588 */ 589svn_error_t * 590svn_wc_locked2(svn_boolean_t *locked_here, 591 svn_boolean_t *locked, 592 svn_wc_context_t *wc_ctx, 593 const char *local_abspath, 594 apr_pool_t *scratch_pool); 595 596/** Set @a *locked to non-zero if @a path is locked, else set it to zero. 597 * 598 * New code should use svn_wc_locked2() instead. 599 * 600 * @deprecated Provided for backward compatibility with the 1.6 API. 601 */ 602SVN_DEPRECATED 603svn_error_t * 604svn_wc_locked(svn_boolean_t *locked, 605 const char *path, 606 apr_pool_t *pool); 607 608 609/** 610 * @defgroup svn_wc_adm_dir_name Name of Subversion's admin dir 611 * @{ 612 */ 613 614/** The default name of the administrative subdirectory. 615 * 616 * Ideally, this would be completely private to wc internals (in fact, 617 * it used to be that adm_subdir() in adm_files.c was the only function 618 * who knew the adm subdir's name). However, import wants to protect 619 * against importing administrative subdirs, so now the name is a 620 * matter of public record. 621 * 622 * @deprecated Provided for backward compatibility with the 1.2 API. 623 */ 624#define SVN_WC_ADM_DIR_NAME ".svn" 625 626 627/** 628 * Return @c TRUE if @a name is the name of the WC administrative 629 * directory. Use @a pool for any temporary allocations. Only works 630 * with base directory names, not paths or URIs. 631 * 632 * For compatibility, the default name (.svn) will always be treated 633 * as an admin dir name, even if the working copy is actually using an 634 * alternative name. 635 * 636 * @since New in 1.3. 637 */ 638svn_boolean_t 639svn_wc_is_adm_dir(const char *name, apr_pool_t *pool); 640 641 642/** 643 * Return the name of the administrative directory. 644 * Use @a pool for any temporary allocations. 645 * 646 * The returned pointer will refer to either a statically allocated 647 * string, or to a string allocated in @a pool. 648 * 649 * @since New in 1.3. 650 */ 651const char * 652svn_wc_get_adm_dir(apr_pool_t *pool); 653 654 655/** 656 * Use @a name for the administrative directory in the working copy. 657 * Use @a pool for any temporary allocations. 658 * 659 * The list of valid names is limited. Currently only ".svn" (the 660 * default) and "_svn" are allowed. 661 * 662 * @note This function changes global (per-process) state and must be 663 * called in a single-threaded context during the initialization of a 664 * Subversion client. 665 * 666 * @since New in 1.3. 667 */ 668svn_error_t * 669svn_wc_set_adm_dir(const char *name, 670 apr_pool_t *pool); 671 672/** @} */ 673 674 675/** 676 * @defgroup svn_wc_externals Externals 677 * @{ 678 */ 679 680/** Callback for external definitions updates 681 * 682 * @a local_abspath is the path on which the external definition was found. 683 * @a old_val and @a new_val are the before and after values of the 684 * SVN_PROP_EXTERNALS property. @a depth is the ambient depth of the 685 * working copy directory at @a local_abspath. 686 * 687 * @since New in 1.7. */ 688typedef svn_error_t *(*svn_wc_external_update_t)(void *baton, 689 const char *local_abspath, 690 const svn_string_t *old_val, 691 const svn_string_t *new_val, 692 svn_depth_t depth, 693 apr_pool_t *scratch_pool); 694 695/** Traversal information is information gathered by a working copy 696 * crawl or update. For example, the before and after values of the 697 * svn:externals property are important after an update, and since 698 * we're traversing the working tree anyway (a complete traversal 699 * during the initial crawl, and a traversal of changed paths during 700 * the checkout/update/switch), it makes sense to gather the 701 * property's values then instead of making a second pass. 702 * 703 * New code should use the svn_wc_external_update_t callback instead. 704 * 705 * @deprecated Provided for backward compatibility with the 1.6 API. 706 */ 707typedef struct svn_wc_traversal_info_t svn_wc_traversal_info_t; 708 709 710/** Return a new, empty traversal info object, allocated in @a pool. 711 * 712 * New code should use the svn_wc_external_update_t callback instead. 713 * 714 * @deprecated Provided for backward compatibility with the 1.6 API. 715 */ 716SVN_DEPRECATED 717svn_wc_traversal_info_t * 718svn_wc_init_traversal_info(apr_pool_t *pool); 719 720/** Set @a *externals_old and @a *externals_new to hash tables representing 721 * changes to values of the svn:externals property on directories 722 * traversed by @a traversal_info. 723 * 724 * @a traversal_info is obtained from svn_wc_init_traversal_info(), but is 725 * only useful after it has been passed through another function, such 726 * as svn_wc_crawl_revisions(), svn_wc_get_update_editor(), 727 * svn_wc_get_switch_editor(), etc. 728 * 729 * Each hash maps <tt>const char *</tt> directory names onto 730 * <tt>const char *</tt> values of the externals property for that directory. 731 * The dir names are full paths -- that is, anchor plus target, not target 732 * alone. The values are not parsed, they are simply copied raw, and are 733 * never NULL: directories that acquired or lost the property are 734 * simply omitted from the appropriate table. Directories whose value 735 * of the property did not change show the same value in each hash. 736 * 737 * The hashes, keys, and values have the same lifetime as @a traversal_info. 738 * 739 * New code should use the svn_wc_external_update_t callback instead. 740 * 741 * @deprecated Provided for backward compatibility with the 1.6 API. 742 */ 743SVN_DEPRECATED 744void 745svn_wc_edited_externals(apr_hash_t **externals_old, 746 apr_hash_t **externals_new, 747 svn_wc_traversal_info_t *traversal_info); 748 749 750/** Set @a *depths to a hash table mapping <tt>const char *</tt> 751 * directory names (directories traversed by @a traversal_info) to 752 * <tt>const char *</tt> values (the depths of those directories, as 753 * converted by svn_depth_to_word()). 754 * 755 * @a traversal_info is obtained from svn_wc_init_traversal_info(), but is 756 * only useful after it has been passed through another function, such 757 * as svn_wc_crawl_revisions(), svn_wc_get_update_editor(), 758 * svn_wc_get_switch_editor(), etc. 759 * 760 * The dir names are full paths -- that is, anchor plus target, not target 761 * alone. The values are not allocated, they are static constant strings. 762 * Although the values are never NULL, not all directories traversed 763 * are necessarily listed. For example, directories which did not 764 * have an svn:externals property set or modified are not included. 765 * 766 * The hashes and keys have the same lifetime as @a traversal_info. 767 * 768 * New code should use the svn_wc_external_update_t callback instead. 769 * 770 * @since New in 1.5. 771 * @deprecated Provided for backward compatibility with the 1.6 API. 772 */ 773SVN_DEPRECATED 774void 775svn_wc_traversed_depths(apr_hash_t **depths, 776 svn_wc_traversal_info_t *traversal_info); 777 778 779/** One external item. This usually represents one line from an 780 * svn:externals description but with the path and URL 781 * canonicalized. 782 * 783 * In order to avoid backwards compatibility problems clients should use 784 * svn_wc_external_item2_create() to allocate and initialize this structure 785 * instead of doing so themselves. 786 * 787 * @since New in 1.5. 788 */ 789typedef struct svn_wc_external_item2_t 790{ 791 /** The name of the subdirectory into which this external should be 792 checked out. This is relative to the parent directory that 793 holds this external item. (Note that these structs are often 794 stored in hash tables with the target dirs as keys, so this 795 field will often be redundant.) */ 796 const char *target_dir; 797 798 /** Where to check out from. This is possibly a relative external URL, as 799 * allowed in externals definitions, but without the peg revision. */ 800 const char *url; 801 802 /** What revision to check out. The only valid kinds for this are 803 svn_opt_revision_number, svn_opt_revision_date, and 804 svn_opt_revision_head. */ 805 svn_opt_revision_t revision; 806 807 /** The peg revision to use when checking out. The only valid kinds are 808 svn_opt_revision_number, svn_opt_revision_date, and 809 svn_opt_revision_head. */ 810 svn_opt_revision_t peg_revision; 811 812} svn_wc_external_item2_t; 813 814/** 815 * Initialize an external item. 816 * Set @a *item to an external item object, allocated in @a pool. 817 * 818 * In order to avoid backwards compatibility problems, this function 819 * is used to initialize and allocate the #svn_wc_external_item2_t 820 * structure rather than doing so explicitly, as the size of this 821 * structure may change in the future. 822 * 823 * The current implementation never returns error, but callers should 824 * still check for error, for compatibility with future versions. 825 * 826 * @since New in 1.8. 827 */ 828svn_error_t * 829svn_wc_external_item2_create(svn_wc_external_item2_t **item, 830 apr_pool_t *pool); 831 832/** Same as svn_wc_external_item2_create() except the pointer to the new 833 * empty item is 'const' which is stupid since the next thing you need to do 834 * is fill in its fields. 835 * 836 * @deprecated Provided for backward compatibility with the 1.7 API. 837 * @since New in 1.5. 838 */ 839SVN_DEPRECATED 840svn_error_t * 841svn_wc_external_item_create(const svn_wc_external_item2_t **item, 842 apr_pool_t *pool); 843 844/** 845 * Return a duplicate of @a item, allocated in @a pool. No part of the new 846 * item will be shared with @a item. 847 * 848 * @since New in 1.5. 849 */ 850svn_wc_external_item2_t * 851svn_wc_external_item2_dup(const svn_wc_external_item2_t *item, 852 apr_pool_t *pool); 853 854/** 855 * One external item. Similar to svn_wc_external_item2_t, except 856 * @a revision is interpreted as both the operational revision and the 857 * peg revision. 858 * 859 * @deprecated Provided for backward compatibility with the 1.4 API. 860 */ 861typedef struct svn_wc_external_item_t 862{ 863 /** Same as #svn_wc_external_item2_t.target_dir */ 864 const char *target_dir; 865 866 /** Same as #svn_wc_external_item2_t.url */ 867 const char *url; 868 869 /** Same as #svn_wc_external_item2_t.revision */ 870 svn_opt_revision_t revision; 871 872} svn_wc_external_item_t; 873 874/** 875 * Return a duplicate of @a item, allocated in @a pool. No part of the new 876 * item will be shared with @a item. 877 * 878 * @since New in 1.3. 879 * 880 * @deprecated Provided for backward compatibility with the 1.4 API. 881 */ 882SVN_DEPRECATED 883svn_wc_external_item_t * 884svn_wc_external_item_dup(const svn_wc_external_item_t *item, 885 apr_pool_t *pool); 886 887/** 888 * If @a externals_p is non-NULL, set @a *externals_p to an array of 889 * #svn_wc_external_item2_t * objects based on @a desc. 890 * 891 * If the format of @a desc is invalid, don't touch @a *externals_p and 892 * return #SVN_ERR_CLIENT_INVALID_EXTERNALS_DESCRIPTION. Thus, if 893 * you just want to check the validity of an externals description, 894 * and don't care about the parsed result, pass NULL for @a externals_p. 895 * 896 * The format of @a desc is the same as for values of the directory 897 * property #SVN_PROP_EXTERNALS. Look there for more details. 898 * 899 * If @a canonicalize_url is @c TRUE, canonicalize the @a url member 900 * of those objects. If the @a url member refers to an absolute URL, 901 * it will be canonicalized as URL consistent with the way URLs are 902 * canonicalized throughout the Subversion API. If, however, the 903 * @a url member makes use of the recognized (SVN-specific) relative 904 * URL syntax for svn:externals, "canonicalization" is an ill-defined 905 * concept which may even result in munging the relative URL syntax 906 * beyond recognition. You've been warned. 907 * 908 * Allocate the table, keys, and values in @a pool. 909 * 910 * @a defining_directory is the path or URL of the directory on which 911 * the svn:externals property corresponding to @a desc is set. 912 * @a defining_directory is only used when constructing error strings. 913 * 914 * @since New in 1.5. 915 */ 916svn_error_t * 917svn_wc_parse_externals_description3(apr_array_header_t **externals_p, 918 const char *defining_directory, 919 const char *desc, 920 svn_boolean_t canonicalize_url, 921 apr_pool_t *pool); 922 923/** 924 * Similar to svn_wc_parse_externals_description3() with @a 925 * canonicalize_url set to @c TRUE, but returns an array of 926 * #svn_wc_external_item_t * objects instead of 927 * #svn_wc_external_item2_t * objects 928 * 929 * @since New in 1.1. 930 * 931 * @deprecated Provided for backward compatibility with the 1.4 API. 932 */ 933SVN_DEPRECATED 934svn_error_t * 935svn_wc_parse_externals_description2(apr_array_header_t **externals_p, 936 const char *parent_directory, 937 const char *desc, 938 apr_pool_t *pool); 939 940/** 941 * Similar to svn_wc_parse_externals_description2(), but returns the 942 * parsed externals in a hash instead of an array. This function 943 * should not be used, as storing the externals in a hash causes their 944 * order of evaluation to be not easily identifiable. 945 * 946 * @deprecated Provided for backward compatibility with the 1.0 API. 947 */ 948SVN_DEPRECATED 949svn_error_t * 950svn_wc_parse_externals_description(apr_hash_t **externals_p, 951 const char *parent_directory, 952 const char *desc, 953 apr_pool_t *pool); 954 955/** @} */ 956 957 958/** 959 * @defgroup svn_wc_notifications Notification callback handling 960 * @{ 961 * 962 * In many cases, the WC library will scan a working copy and make 963 * changes. The caller usually wants to know when each of these changes 964 * has been made, so that it can display some kind of notification to 965 * the user. 966 * 967 * These notifications have a standard callback function type, which 968 * takes the path of the file that was affected, and a caller- 969 * supplied baton. 970 * 971 * @note The callback is a 'void' return -- this is a simple 972 * reporting mechanism, rather than an opportunity for the caller to 973 * alter the operation of the WC library. 974 * 975 * @note Some of the actions are used across several 976 * different Subversion commands. For example, the update actions are 977 * also used for checkouts, switches, and merges. 978 */ 979 980/** The type of action occurring. */ 981typedef enum svn_wc_notify_action_t 982{ 983 /** Adding a path to revision control. */ 984 svn_wc_notify_add = 0, 985 986 /** Copying a versioned path. */ 987 svn_wc_notify_copy, 988 989 /** Deleting a versioned path. */ 990 svn_wc_notify_delete, 991 992 /** Restoring a missing path from the pristine text-base. */ 993 svn_wc_notify_restore, 994 995 /** Reverting a modified path. */ 996 svn_wc_notify_revert, 997 998 /** A revert operation has failed. */ 999 svn_wc_notify_failed_revert, 1000 1001 /** Resolving a conflict. */ 1002 svn_wc_notify_resolved, 1003 1004 /** Skipping a path. */ 1005 svn_wc_notify_skip, 1006 1007 /** Got a delete in an update. */ 1008 svn_wc_notify_update_delete, 1009 1010 /** Got an add in an update. */ 1011 svn_wc_notify_update_add, 1012 1013 /** Got any other action in an update. */ 1014 svn_wc_notify_update_update, 1015 1016 /** The last notification in an update (including updates of externals). */ 1017 svn_wc_notify_update_completed, 1018 1019 /** Updating an external module. */ 1020 svn_wc_notify_update_external, 1021 1022 /** The last notification in a status (including status on externals). */ 1023 svn_wc_notify_status_completed, 1024 1025 /** Running status on an external module. */ 1026 svn_wc_notify_status_external, 1027 1028 /** Committing a modification. */ 1029 svn_wc_notify_commit_modified, 1030 1031 /** Committing an addition. */ 1032 svn_wc_notify_commit_added, 1033 1034 /** Committing a deletion. */ 1035 svn_wc_notify_commit_deleted, 1036 1037 /** Committing a replacement. */ 1038 svn_wc_notify_commit_replaced, 1039 1040 /** Transmitting post-fix text-delta data for a file. */ 1041 svn_wc_notify_commit_postfix_txdelta, 1042 1043 /** Processed a single revision's blame. */ 1044 svn_wc_notify_blame_revision, 1045 1046 /** Locking a path. @since New in 1.2. */ 1047 svn_wc_notify_locked, 1048 1049 /** Unlocking a path. @since New in 1.2. */ 1050 svn_wc_notify_unlocked, 1051 1052 /** Failed to lock a path. @since New in 1.2. */ 1053 svn_wc_notify_failed_lock, 1054 1055 /** Failed to unlock a path. @since New in 1.2. */ 1056 svn_wc_notify_failed_unlock, 1057 1058 /** Tried adding a path that already exists. @since New in 1.5. */ 1059 svn_wc_notify_exists, 1060 1061 /** Changelist name set. @since New in 1.5. */ 1062 svn_wc_notify_changelist_set, 1063 1064 /** Changelist name cleared. @since New in 1.5. */ 1065 svn_wc_notify_changelist_clear, 1066 1067 /** Warn user that a path has moved from one changelist to another. 1068 @since New in 1.5. 1069 @deprecated As of 1.7, separate clear and set notifications are sent. */ 1070 svn_wc_notify_changelist_moved, 1071 1072 /** A merge operation (to path) has begun. See #svn_wc_notify_t.merge_range. 1073 @since New in 1.5. */ 1074 svn_wc_notify_merge_begin, 1075 1076 /** A merge operation (to path) from a foreign repository has begun. 1077 See #svn_wc_notify_t.merge_range. @since New in 1.5. */ 1078 svn_wc_notify_foreign_merge_begin, 1079 1080 /** Replace notification. @since New in 1.5. */ 1081 svn_wc_notify_update_replace, 1082 1083 /** Property added. @since New in 1.6. */ 1084 svn_wc_notify_property_added, 1085 1086 /** Property updated. @since New in 1.6. */ 1087 svn_wc_notify_property_modified, 1088 1089 /** Property deleted. @since New in 1.6. */ 1090 svn_wc_notify_property_deleted, 1091 1092 /** Nonexistent property deleted. @since New in 1.6. */ 1093 svn_wc_notify_property_deleted_nonexistent, 1094 1095 /** Revprop set. @since New in 1.6. */ 1096 svn_wc_notify_revprop_set, 1097 1098 /** Revprop deleted. @since New in 1.6. */ 1099 svn_wc_notify_revprop_deleted, 1100 1101 /** The last notification in a merge. @since New in 1.6. */ 1102 svn_wc_notify_merge_completed, 1103 1104 /** The path is a tree-conflict victim of the intended action (*not* 1105 * a persistent tree-conflict from an earlier operation, but *this* 1106 * operation caused the tree-conflict). @since New in 1.6. */ 1107 svn_wc_notify_tree_conflict, 1108 1109 /** The path is a subdirectory referenced in an externals definition 1110 * which is unable to be operated on. @since New in 1.6. */ 1111 svn_wc_notify_failed_external, 1112 1113 /** Starting an update operation. @since New in 1.7. */ 1114 svn_wc_notify_update_started, 1115 1116 /** An update tried to add a file or directory at a path where 1117 * a separate working copy was found. @since New in 1.7. */ 1118 svn_wc_notify_update_skip_obstruction, 1119 1120 /** An explicit update tried to update a file or directory that 1121 * doesn't live in the repository and can't be brought in. 1122 * @since New in 1.7. */ 1123 svn_wc_notify_update_skip_working_only, 1124 1125 /** An update tried to update a file or directory to which access could 1126 * not be obtained. @since New in 1.7. */ 1127 svn_wc_notify_update_skip_access_denied, 1128 1129 /** An update operation removed an external working copy. 1130 * @since New in 1.7. */ 1131 svn_wc_notify_update_external_removed, 1132 1133 /** A node below an existing node was added during update. 1134 * @since New in 1.7. */ 1135 svn_wc_notify_update_shadowed_add, 1136 1137 /** A node below an existing node was updated during update. 1138 * @since New in 1.7. */ 1139 svn_wc_notify_update_shadowed_update, 1140 1141 /** A node below an existing node was deleted during update. 1142 * @since New in 1.7. */ 1143 svn_wc_notify_update_shadowed_delete, 1144 1145 /** The mergeinfo on path was updated. @since New in 1.7. */ 1146 svn_wc_notify_merge_record_info, 1147 1148 /** A working copy directory was upgraded to the latest format. 1149 * @since New in 1.7. */ 1150 svn_wc_notify_upgraded_path, 1151 1152 /** Mergeinfo describing a merge was recorded. 1153 * @since New in 1.7. */ 1154 svn_wc_notify_merge_record_info_begin, 1155 1156 /** Mergeinfo was removed due to elision. 1157 * @since New in 1.7. */ 1158 svn_wc_notify_merge_elide_info, 1159 1160 /** A file in the working copy was patched. 1161 * @since New in 1.7. */ 1162 svn_wc_notify_patch, 1163 1164 /** A hunk from a patch was applied. 1165 * @since New in 1.7. */ 1166 svn_wc_notify_patch_applied_hunk, 1167 1168 /** A hunk from a patch was rejected. 1169 * @since New in 1.7. */ 1170 svn_wc_notify_patch_rejected_hunk, 1171 1172 /** A hunk from a patch was found to already be applied. 1173 * @since New in 1.7. */ 1174 svn_wc_notify_patch_hunk_already_applied, 1175 1176 /** Committing a non-overwriting copy (path is the target of the 1177 * copy, not the source). 1178 * @since New in 1.7. */ 1179 svn_wc_notify_commit_copied, 1180 1181 /** Committing an overwriting (replace) copy (path is the target of 1182 * the copy, not the source). 1183 * @since New in 1.7. */ 1184 svn_wc_notify_commit_copied_replaced, 1185 1186 /** The server has instructed the client to follow a URL 1187 * redirection. 1188 * @since New in 1.7. */ 1189 svn_wc_notify_url_redirect, 1190 1191 /** The operation was attempted on a path which doesn't exist. 1192 * @since New in 1.7. */ 1193 svn_wc_notify_path_nonexistent, 1194 1195 /** Removing a path by excluding it. 1196 * @since New in 1.7. */ 1197 svn_wc_notify_exclude, 1198 1199 /** Operation failed because the node remains in conflict 1200 * @since New in 1.7. */ 1201 svn_wc_notify_failed_conflict, 1202 1203 /** Operation failed because an added node is missing 1204 * @since New in 1.7. */ 1205 svn_wc_notify_failed_missing, 1206 1207 /** Operation failed because a node is out of date 1208 * @since New in 1.7. */ 1209 svn_wc_notify_failed_out_of_date, 1210 1211 /** Operation failed because an added parent is not selected 1212 * @since New in 1.7. */ 1213 svn_wc_notify_failed_no_parent, 1214 1215 /** Operation failed because a node is locked by another user and/or 1216 * working copy. @since New in 1.7. */ 1217 svn_wc_notify_failed_locked, 1218 1219 /** Operation failed because the operation was forbidden by the server. 1220 * @since New in 1.7. */ 1221 svn_wc_notify_failed_forbidden_by_server, 1222 1223 /** The operation skipped the path because it was conflicted. 1224 * @since New in 1.7. */ 1225 svn_wc_notify_skip_conflicted, 1226 1227 /** Just the lock on a file was removed during update. 1228 * @since New in 1.8. */ 1229 svn_wc_notify_update_broken_lock, 1230 1231 /** Operation failed because a node is obstructed. 1232 * @since New in 1.8. */ 1233 svn_wc_notify_failed_obstruction, 1234 1235 /** Conflict resolver is starting. 1236 * This can be used by clients to detect when to display conflict summary 1237 * information, for example. 1238 * @since New in 1.8. */ 1239 svn_wc_notify_conflict_resolver_starting, 1240 1241 /** Conflict resolver is done. 1242 * This can be used by clients to detect when to display conflict summary 1243 * information, for example. 1244 * @since New in 1.8. */ 1245 svn_wc_notify_conflict_resolver_done, 1246 1247 /** The current operation left local changes of something that was deleted 1248 * The changes are available on (and below) the notified path 1249 * @since New in 1.8. */ 1250 svn_wc_notify_left_local_modifications, 1251 1252 /** A copy from a foreign repository has started 1253 * @since New in 1.8. */ 1254 svn_wc_notify_foreign_copy_begin, 1255 1256 /** A move in the working copy has been broken, i.e. degraded into a 1257 * copy + delete. The notified path is the move source (the deleted path). 1258 * ### TODO: Provide path to move destination as well? 1259 * @since New in 1.8. */ 1260 svn_wc_notify_move_broken, 1261 1262 /** Running cleanup on an external module. 1263 * @since New in 1.9. */ 1264 svn_wc_notify_cleanup_external, 1265 1266 /** The operation failed because the operation (E.g. commit) is only valid 1267 * if the operation includes this path. 1268 * @since New in 1.9. */ 1269 svn_wc_notify_failed_requires_target, 1270 1271 /** Running info on an external module. 1272 * @since New in 1.9. */ 1273 svn_wc_notify_info_external, 1274 1275 /** Finalizing commit. 1276 * @since New in 1.9. */ 1277 svn_wc_notify_commit_finalizing 1278} svn_wc_notify_action_t; 1279 1280 1281/** The type of notification that is occurring. */ 1282typedef enum svn_wc_notify_state_t 1283{ 1284 svn_wc_notify_state_inapplicable = 0, 1285 1286 /** Notifier doesn't know or isn't saying. */ 1287 svn_wc_notify_state_unknown, 1288 1289 /** The state did not change. */ 1290 svn_wc_notify_state_unchanged, 1291 1292 /** The item wasn't present. */ 1293 svn_wc_notify_state_missing, 1294 1295 /** An unversioned item obstructed work. */ 1296 svn_wc_notify_state_obstructed, 1297 1298 /** Pristine state was modified. */ 1299 svn_wc_notify_state_changed, 1300 1301 /** Modified state had mods merged in. */ 1302 svn_wc_notify_state_merged, 1303 1304 /** Modified state got conflicting mods. */ 1305 svn_wc_notify_state_conflicted, 1306 1307 /** The source to copy the file from is missing. */ 1308 svn_wc_notify_state_source_missing 1309 1310} svn_wc_notify_state_t; 1311 1312/** 1313 * What happened to a lock during an operation. 1314 * 1315 * @since New in 1.2. 1316 */ 1317typedef enum svn_wc_notify_lock_state_t 1318{ 1319 svn_wc_notify_lock_state_inapplicable = 0, 1320 1321 svn_wc_notify_lock_state_unknown, 1322 1323 /** The lock wasn't changed. */ 1324 svn_wc_notify_lock_state_unchanged, 1325 1326 /** The item was locked. */ 1327 svn_wc_notify_lock_state_locked, 1328 1329 /** The item was unlocked. */ 1330 svn_wc_notify_lock_state_unlocked 1331 1332} svn_wc_notify_lock_state_t; 1333 1334/** 1335 * Structure used in the #svn_wc_notify_func2_t function. 1336 * 1337 * @c kind, @c content_state, @c prop_state and @c lock_state are from 1338 * after @c action, not before. 1339 * 1340 * @note If @c action is #svn_wc_notify_update_completed, then @c path has 1341 * already been installed, so it is legitimate for an implementation of 1342 * #svn_wc_notify_func2_t to examine @c path in the working copy. 1343 * 1344 * @note The purpose of the @c kind, @c mime_type, @c content_state, and 1345 * @c prop_state fields is to provide "for free" information that an 1346 * implementation is likely to want, and which it would otherwise be 1347 * forced to deduce via expensive operations such as reading entries 1348 * and properties. However, if the caller does not have this 1349 * information, it will simply pass the corresponding `*_unknown' 1350 * values, and it is up to the implementation how to handle that 1351 * (i.e., whether to attempt deduction, or just to punt and 1352 * give a less informative notification). 1353 * 1354 * @note Callers of notification functions should use svn_wc_create_notify() 1355 * or svn_wc_create_notify_url() to create structures of this type to allow 1356 * for extensibility. 1357 * 1358 * @since New in 1.2. 1359 */ 1360typedef struct svn_wc_notify_t { 1361 1362 /** Path, either absolute or relative to the current working directory 1363 * (i.e., not relative to an anchor). @c path is "." or another valid path 1364 * value for compatibility reasons when the real target is a url that 1365 * is available in @c url. */ 1366 const char *path; 1367 1368 /** Action that describes what happened to #svn_wc_notify_t.path. */ 1369 svn_wc_notify_action_t action; 1370 1371 /** Node kind of @c path. */ 1372 svn_node_kind_t kind; 1373 1374 /** If non-NULL, indicates the mime-type of @c path. 1375 * It is always @c NULL for directories. */ 1376 const char *mime_type; 1377 1378 /** Points to the lock structure received from the repository when 1379 * @c action is #svn_wc_notify_locked. For other actions, it is 1380 * @c NULL. */ 1381 const svn_lock_t *lock; 1382 1383 /** Points to an error describing the reason for the failure when @c 1384 * action is one of the following: #svn_wc_notify_failed_lock, 1385 * #svn_wc_notify_failed_unlock, #svn_wc_notify_failed_external. 1386 * Is @c NULL otherwise. */ 1387 svn_error_t *err; 1388 1389 /** The type of notification that is occurring about node content. */ 1390 svn_wc_notify_state_t content_state; 1391 1392 /** The type of notification that is occurring about node properties. */ 1393 svn_wc_notify_state_t prop_state; 1394 1395 /** Reflects the addition or removal of a lock token in the working copy. */ 1396 svn_wc_notify_lock_state_t lock_state; 1397 1398 /** When @c action is #svn_wc_notify_update_completed, target revision 1399 * of the update, or #SVN_INVALID_REVNUM if not available; when @c 1400 * action is #svn_wc_notify_blame_revision, processed revision; Since 1401 * Subversion 1.7 when action is #svn_wc_notify_update_update or 1402 * #svn_wc_notify_update_add, the target revision. 1403 * In all other cases, it is #SVN_INVALID_REVNUM. 1404 */ 1405 svn_revnum_t revision; 1406 1407 /** If @c action pertains to a changelist, this is the changelist name. 1408 * In all other cases, it is @c NULL. @since New in 1.5 */ 1409 const char *changelist_name; 1410 1411 /** When @c action is #svn_wc_notify_merge_begin or 1412 * #svn_wc_notify_foreign_merge_begin or 1413 * #svn_wc_notify_merge_record_info_begin, and both the 1414 * left and right sides of the merge are from the same URL. In all 1415 * other cases, it is @c NULL. @since New in 1.5 */ 1416 svn_merge_range_t *merge_range; 1417 1418 /** Similar to @c path, but if non-NULL the notification is about a url. 1419 * @since New in 1.6 */ 1420 const char *url; 1421 1422 /** If non-NULL, specifies an absolute path prefix that can be subtracted 1423 * from the start of the absolute path in @c path or @c url. Its purpose 1424 * is to allow notification to remove a common prefix from all the paths 1425 * displayed for an operation. @since New in 1.6 */ 1426 const char *path_prefix; 1427 1428 /** If @c action relates to properties, specifies the name of the property. 1429 * @since New in 1.6 */ 1430 const char *prop_name; 1431 1432 /** If @c action is #svn_wc_notify_blame_revision, contains a list of 1433 * revision properties for the specified revision 1434 * @since New in 1.6 */ 1435 apr_hash_t *rev_props; 1436 1437 /** If @c action is #svn_wc_notify_update_update or 1438 * #svn_wc_notify_update_add, contains the revision before the update. 1439 * In all other cases, it is #SVN_INVALID_REVNUM. 1440 * @since New in 1.7 */ 1441 svn_revnum_t old_revision; 1442 1443 /** These fields are used by svn patch to identify the 1444 * hunk the notification is for. They are line-based 1445 * offsets and lengths parsed from the unidiff hunk header. 1446 * @since New in 1.7. */ 1447 /* @{ */ 1448 svn_linenum_t hunk_original_start; 1449 svn_linenum_t hunk_original_length; 1450 svn_linenum_t hunk_modified_start; 1451 svn_linenum_t hunk_modified_length; 1452 /* @} */ 1453 1454 /** The line at which a hunk was matched (and applied). 1455 * @since New in 1.7. */ 1456 svn_linenum_t hunk_matched_line; 1457 1458 /** The fuzz factor the hunk was applied with. 1459 * @since New in 1.7 */ 1460 svn_linenum_t hunk_fuzz; 1461 1462 /* NOTE: Add new fields at the end to preserve binary compatibility. 1463 Also, if you add fields here, you have to update svn_wc_create_notify 1464 and svn_wc_dup_notify. */ 1465} svn_wc_notify_t; 1466 1467/** 1468 * Allocate an #svn_wc_notify_t structure in @a pool, initialize and return 1469 * it. 1470 * 1471 * Set the @c path field of the created struct to @a path, and @c action to 1472 * @a action. Set all other fields to their @c _unknown, @c NULL or 1473 * invalid value, respectively. Make only a shallow copy of the pointer 1474 * @a path. 1475 * 1476 * @since New in 1.2. 1477 */ 1478svn_wc_notify_t * 1479svn_wc_create_notify(const char *path, 1480 svn_wc_notify_action_t action, 1481 apr_pool_t *pool); 1482 1483/** 1484 * Allocate an #svn_wc_notify_t structure in @a pool, initialize and return 1485 * it. 1486 * 1487 * Set the @c url field of the created struct to @a url, @c path to "." and @c 1488 * action to @a action. Set all other fields to their @c _unknown, @c NULL or 1489 * invalid value, respectively. Make only a shallow copy of the pointer 1490 * @a url. 1491 * 1492 * @since New in 1.6. 1493 */ 1494svn_wc_notify_t * 1495svn_wc_create_notify_url(const char *url, 1496 svn_wc_notify_action_t action, 1497 apr_pool_t *pool); 1498 1499/** 1500 * Return a deep copy of @a notify, allocated in @a pool. 1501 * 1502 * @since New in 1.2. 1503 */ 1504svn_wc_notify_t * 1505svn_wc_dup_notify(const svn_wc_notify_t *notify, 1506 apr_pool_t *pool); 1507 1508/** 1509 * Notify the world that @a notify->action has happened to @a notify->path. 1510 * 1511 * Recommendation: callers of #svn_wc_notify_func2_t should avoid 1512 * invoking it multiple times on the same path within a given 1513 * operation, and implementations should not bother checking for such 1514 * duplicate calls. For example, in an update, the caller should not 1515 * invoke the notify func on receiving a prop change and then again 1516 * on receiving a text change. Instead, wait until all changes have 1517 * been received, and then invoke the notify func once (from within 1518 * an #svn_delta_editor_t's close_file(), for example), passing 1519 * the appropriate @a notify->content_state and @a notify->prop_state flags. 1520 * 1521 * @since New in 1.2. 1522 */ 1523typedef void (*svn_wc_notify_func2_t)(void *baton, 1524 const svn_wc_notify_t *notify, 1525 apr_pool_t *pool); 1526 1527/** 1528 * Similar to #svn_wc_notify_func2_t, but takes the information as arguments 1529 * instead of struct fields. 1530 * 1531 * @deprecated Provided for backward compatibility with the 1.1 API. 1532 */ 1533typedef void (*svn_wc_notify_func_t)(void *baton, 1534 const char *path, 1535 svn_wc_notify_action_t action, 1536 svn_node_kind_t kind, 1537 const char *mime_type, 1538 svn_wc_notify_state_t content_state, 1539 svn_wc_notify_state_t prop_state, 1540 svn_revnum_t revision); 1541 1542/** @} */ 1543 1544 1545/** 1546 * Interactive conflict handling 1547 * 1548 * @defgroup svn_wc_conflict Conflict callback functionality 1549 * @{ 1550 * 1551 * This API gives a Subversion client application the opportunity to 1552 * define a callback that allows the user to resolve conflicts 1553 * interactively during updates and merges. 1554 * 1555 * If a conflict is discovered, libsvn_wc invokes the callback with an 1556 * #svn_wc_conflict_description_t. This structure describes the 1557 * path in conflict, whether it's a text or property conflict, and may 1558 * also present up to three files that can be used to resolve the 1559 * conflict (perhaps by launching an editor or 3rd-party merging 1560 * tool). The structure also provides a possible fourth file (@c 1561 * merged_file) which, if not NULL, represents libsvn_wc's attempt to 1562 * contextually merge the first three files. (Note that libsvn_wc 1563 * will not attempt to merge a file that it believes is binary, and it 1564 * will only attempt to merge property values it believes to be a 1565 * series of multi-line text.) 1566 * 1567 * When the callback is finished interacting with the user, it 1568 * responds by returning a #svn_wc_conflict_result_t. This 1569 * structure indicates whether the user wants to postpone the conflict 1570 * for later (allowing libsvn_wc to mark the path "conflicted" as 1571 * usual), or whether the user wants libsvn_wc to use one of the four 1572 * files as the "final" state for resolving the conflict immediately. 1573 * 1574 * Note that the callback is at liberty (and encouraged) to merge the 1575 * three files itself. If it does so, it signals this to libsvn_wc by 1576 * returning a choice of #svn_wc_conflict_choose_merged. To return 1577 * the 'final' merged file to libsvn_wc, the callback has the option of 1578 * either: 1579 * 1580 * - editing the original @c merged_file in-place 1581 * 1582 * or, if libsvn_wc never supplied a merged_file in the 1583 * description structure (i.e. passed NULL for that field), 1584 * 1585 * - return the merged file in the #svn_wc_conflict_result_t. 1586 * 1587 */ 1588 1589/** The type of action being attempted on an object. 1590 * 1591 * @since New in 1.5. 1592 */ 1593typedef enum svn_wc_conflict_action_t 1594{ 1595 svn_wc_conflict_action_edit, /**< attempting to change text or props */ 1596 svn_wc_conflict_action_add, /**< attempting to add object */ 1597 svn_wc_conflict_action_delete, /**< attempting to delete object */ 1598 svn_wc_conflict_action_replace /**< attempting to replace object, 1599 @since New in 1.7 */ 1600} svn_wc_conflict_action_t; 1601 1602 1603/** The pre-existing condition which is causing a state of conflict. 1604 * 1605 * @since New in 1.5. 1606 */ 1607typedef enum svn_wc_conflict_reason_t 1608{ 1609 /** Local edits are already present */ 1610 svn_wc_conflict_reason_edited, 1611 /** Another object is in the way */ 1612 svn_wc_conflict_reason_obstructed, 1613 /** Object is already schedule-delete */ 1614 svn_wc_conflict_reason_deleted, 1615 /** Object is unknown or missing */ 1616 svn_wc_conflict_reason_missing, 1617 /** Object is unversioned */ 1618 svn_wc_conflict_reason_unversioned, 1619 /** Object is already added or schedule-add. @since New in 1.6. */ 1620 svn_wc_conflict_reason_added, 1621 /** Object is already replaced. @since New in 1.7. */ 1622 svn_wc_conflict_reason_replaced, 1623 /** Object is moved away. @since New in 1.8. */ 1624 svn_wc_conflict_reason_moved_away, 1625 /** Object is moved here. @since New in 1.8. */ 1626 svn_wc_conflict_reason_moved_here 1627 1628} svn_wc_conflict_reason_t; 1629 1630 1631/** The type of conflict being described by an 1632 * #svn_wc_conflict_description2_t (see below). 1633 * 1634 * @since New in 1.5. 1635 */ 1636typedef enum svn_wc_conflict_kind_t 1637{ 1638 /** textual conflict (on a file) */ 1639 svn_wc_conflict_kind_text, 1640 /** property conflict (on a file or dir) */ 1641 svn_wc_conflict_kind_property, 1642 /** tree conflict (on a dir) @since New in 1.6. */ 1643 svn_wc_conflict_kind_tree 1644} svn_wc_conflict_kind_t; 1645 1646 1647/** The user operation that exposed a conflict. 1648 * 1649 * @since New in 1.6. 1650 */ 1651typedef enum svn_wc_operation_t 1652{ 1653 svn_wc_operation_none = 0, 1654 svn_wc_operation_update, 1655 svn_wc_operation_switch, 1656 svn_wc_operation_merge 1657 1658} svn_wc_operation_t; 1659 1660 1661/** Info about one of the conflicting versions of a node. Each field may 1662 * have its respective null/invalid/unknown value if the corresponding 1663 * information is not relevant or not available. 1664 * 1665 * @todo Consider making some or all of the info mandatory, to reduce 1666 * complexity. 1667 * 1668 * @note Fields may be added to the end of this structure in future 1669 * versions. Therefore, to preserve binary compatibility, users 1670 * should not directly allocate structures of this type. 1671 * 1672 * @see svn_wc_conflict_version_create() 1673 * @see svn_wc_conflict_version_dup() 1674 * 1675 * @since New in 1.6. 1676*/ 1677typedef struct svn_wc_conflict_version_t 1678{ 1679 /** @name Where to find this node version in a repository */ 1680 /**@{*/ 1681 1682 /** URL of repository root */ 1683 const char *repos_url; 1684 1685 /** revision at which to look up path_in_repos */ 1686 svn_revnum_t peg_rev; 1687 1688 /** path within repos; must not start with '/' */ 1689 /* ### should have been called repos_relpath, but we can't change this. */ 1690 const char *path_in_repos; 1691 /** @} */ 1692 1693 /** The node kind. Can be any kind, including 'none' or 'unknown'. */ 1694 svn_node_kind_t node_kind; 1695 1696 /** UUID of the repository (or NULL if unknown.) 1697 * @since New in 1.8. */ 1698 const char *repos_uuid; 1699 1700 /* @todo Add metadata about a local copy of the node, if and when 1701 * we store one. */ 1702 1703 /* Remember to update svn_wc_conflict_version_create() and 1704 * svn_wc_conflict_version_dup() in case you add fields to this struct. */ 1705} svn_wc_conflict_version_t; 1706 1707/** 1708 * Allocate an #svn_wc_conflict_version_t structure in @a pool, 1709 * initialize to contain a conflict origin, and return it. 1710 * 1711 * Set the @c repos_url field of the created struct to @a repos_root_url, 1712 * the @c path_in_repos field to @a repos_relpath, the @c peg_rev field to 1713 * @a revision and the @c node_kind to @a kind. Make only shallow 1714 * copies of the pointer arguments. 1715 * 1716 * @a repos_root_url, @a repos_relpath and @a revision must be valid, 1717 * non-null values. @a repos_uuid should be a valid UUID, but can be 1718 * NULL if unknown. @a kind can be any kind, even 'none' or 'unknown'. 1719 * 1720 * @since New in 1.8. 1721 */ 1722svn_wc_conflict_version_t * 1723svn_wc_conflict_version_create2(const char *repos_root_url, 1724 const char *repos_uuid, 1725 const char *repos_relpath, 1726 svn_revnum_t revision, 1727 svn_node_kind_t kind, 1728 apr_pool_t *result_pool); 1729 1730/** Similar to svn_wc_conflict_version_create2(), but doesn't set all 1731 * required values. 1732 * 1733 * @since New in 1.6. 1734 * @deprecated Provided for backward compatibility with the 1.7 API. 1735 */ 1736SVN_DEPRECATED 1737svn_wc_conflict_version_t * 1738svn_wc_conflict_version_create(const char *repos_url, 1739 const char *path_in_repos, 1740 svn_revnum_t peg_rev, 1741 svn_node_kind_t node_kind, 1742 apr_pool_t *pool); 1743 1744/** Return a duplicate of @a version, allocated in @a pool. 1745 * No part of the new version will be shared with @a version. 1746 * 1747 * @since New in 1.6. 1748 */ 1749svn_wc_conflict_version_t * 1750svn_wc_conflict_version_dup(const svn_wc_conflict_version_t *version, 1751 apr_pool_t *pool); 1752 1753 1754/** A struct that describes a conflict that has occurred in the 1755 * working copy. 1756 * 1757 * The conflict described by this structure is one of: 1758 * - a conflict on the content of the file node @a local_abspath 1759 * - a conflict on the property @a property_name of @a local_abspath 1760 * - a tree conflict, of which @a local_abspath is the victim 1761 * Be aware that the victim of a tree conflict can be a non-existent node. 1762 * The three kinds of conflict are distinguished by @a kind. 1763 * 1764 * @note Fields may be added to the end of this structure in future 1765 * versions. Therefore, to preserve binary compatibility, users 1766 * should not directly allocate structures of this type but should use 1767 * svn_wc_conflict_description_create_text2() or 1768 * svn_wc_conflict_description_create_prop2() or 1769 * svn_wc_conflict_description_create_tree2() instead. 1770 * 1771 * @since New in 1.7. 1772 */ 1773typedef struct svn_wc_conflict_description2_t 1774{ 1775 /** The path that is in conflict (for a tree conflict, it is the victim) */ 1776 const char *local_abspath; 1777 1778 /** The node type of the local node involved in this conflict. 1779 * For a tree conflict, this is the node kind of the tree conflict victim. 1780 * For the left/right node kinds of the incoming conflicting change see 1781 * src_left_version->node_kind and src_right_version->node_kind. */ 1782 svn_node_kind_t node_kind; 1783 1784 /** What sort of conflict are we describing? */ 1785 svn_wc_conflict_kind_t kind; 1786 1787 /** The name of the property whose conflict is being described. 1788 * (Only if @a kind is 'property'; else undefined.) */ 1789 const char *property_name; 1790 1791 /** Whether svn thinks ('my' version of) @c path is a 'binary' file. 1792 * (Only if @c kind is 'text', else undefined.) */ 1793 svn_boolean_t is_binary; 1794 1795 /** The svn:mime-type property of ('my' version of) @c path, if available, 1796 * else NULL. 1797 * (Only if @c kind is 'text', else undefined.) */ 1798 const char *mime_type; 1799 1800 /** The incoming action being attempted on the conflicted node or property. 1801 * When @c kind is 'text', this action must be 'edit', but generally it can 1802 * be any kind of possible change. */ 1803 svn_wc_conflict_action_t action; 1804 1805 /** The local change or state of the target node or property, relative 1806 * to its merge-left source, that conflicts with the incoming action. 1807 * When @c kind is 'text', this must be 'edited', but generally it can 1808 * be any kind of possible change. 1809 * Note that 'local' does not always refer to a working copy. A change 1810 * can be local to the target branch of a merge operation, for example, 1811 * and is not necessarily visible in a working copy of the target branch 1812 * at any given revision. */ 1813 svn_wc_conflict_reason_t reason; 1814 1815 /** If this is text-conflict and involves the merging of two files 1816 * descended from a common ancestor, here are the paths of up to 1817 * four fulltext files that can be used to interactively resolve the 1818 * conflict. 1819 * 1820 * @a base_abspath, @a their_abspath and @a my_abspath are absolute 1821 * paths. 1822 * 1823 * ### Is @a merged_file relative to some directory, or absolute? 1824 * 1825 * All four files will be in repository-normal form -- LF 1826 * line endings and contracted keywords. (If any of these files are 1827 * not available, they default to NULL.) 1828 * 1829 * On the other hand, if this is a property-conflict, then these 1830 * paths represent temporary files that contain the three different 1831 * property-values in conflict. The fourth path (@c merged_file) 1832 * may or may not be NULL; if set, it represents libsvn_wc's 1833 * attempt to merge the property values together. (Remember that 1834 * property values are technically binary values, and thus can't 1835 * always be merged.) 1836 */ 1837 const char *base_abspath; /* common ancestor of the two files being merged */ 1838 1839 /** their version of the file */ 1840 /* ### BH: For properties this field contains the reference to 1841 the property rejection (.prej) file */ 1842 const char *their_abspath; 1843 1844 /** my locally-edited version of the file */ 1845 const char *my_abspath; 1846 1847 /** merged version; may contain conflict markers 1848 * ### For property conflicts, this contains 'their_abspath'. */ 1849 const char *merged_file; 1850 1851 /** The operation that exposed the conflict. 1852 * Used only for tree conflicts. 1853 */ 1854 svn_wc_operation_t operation; 1855 1856 /** Info on the "merge-left source" or "older" version of incoming change. */ 1857 const svn_wc_conflict_version_t *src_left_version; 1858 1859 /** Info on the "merge-right source" or "their" version of incoming change. */ 1860 const svn_wc_conflict_version_t *src_right_version; 1861 1862 /** For property conflicts, the absolute path to the .prej file. 1863 * @since New in 1.9. */ 1864 const char *prop_reject_abspath; 1865 1866 /** For property conflicts, the local base value of the property, i.e. the 1867 * value of the property as of the BASE revision of the working copy. 1868 * For conflicts created during update/switch this contains the 1869 * post-update/switch property value. The pre-update/switch value can 1870 * be found in prop_value_incoming_old. 1871 * Only set if available, so might be @c NULL. 1872 * @since New in 1.9. */ 1873 const svn_string_t *prop_value_base; 1874 1875 /** For property conflicts, the local working value of the property, 1876 * i.e. the value of the property in the working copy, possibly with 1877 * local modiciations. 1878 * Only set if available, so might be @c NULL. 1879 * @since New in 1.9. */ 1880 const svn_string_t *prop_value_working; 1881 1882 /** For property conflicts, the incoming old value of the property, 1883 * i.e. the value the property had at @c src_left_version. 1884 * Only set if available, so might be @c NULL. 1885 * @since New in 1.9 */ 1886 const svn_string_t *prop_value_incoming_old; 1887 1888 /** For property conflicts, the incoming new value of the property, 1889 * i.e. the value the property had at @c src_right_version. 1890 * Only set if available, so might be @c NULL. 1891 * @since New in 1.9 */ 1892 const svn_string_t *prop_value_incoming_new; 1893 1894/* NOTE: Add new fields at the end to preserve binary compatibility. 1895 Also, if you add fields here, you have to update 1896 svn_wc_conflict_description2_dup and perhaps 1897 svn_wc_conflict_description_create_text2, 1898 svn_wc_conflict_description_create_prop2, and 1899 svn_wc_conflict_description_create_tree2. */ 1900} svn_wc_conflict_description2_t; 1901 1902 1903/** Similar to #svn_wc_conflict_description2_t, but with relative paths and 1904 * adm_access batons. Passed to #svn_wc_conflict_resolver_func_t. 1905 * 1906 * @since New in 1.5. 1907 * @deprecated Provided for backward compatibility with the 1.6 API. 1908 */ 1909typedef struct svn_wc_conflict_description_t 1910{ 1911 /** The path that is in conflict (for a tree conflict, it is the victim) */ 1912 const char *path; 1913 1914 /** The node type of the path being operated on (for a tree conflict, 1915 * ### which version?) */ 1916 svn_node_kind_t node_kind; 1917 1918 /** What sort of conflict are we describing? */ 1919 svn_wc_conflict_kind_t kind; 1920 1921 /** The name of the property whose conflict is being described. 1922 * (Only if @a kind is 'property'; else undefined.) */ 1923 const char *property_name; 1924 1925 /** Whether svn thinks ('my' version of) @c path is a 'binary' file. 1926 * (Only if @c kind is 'text', else undefined.) */ 1927 svn_boolean_t is_binary; 1928 1929 /** The svn:mime-type property of ('my' version of) @c path, if available, 1930 * else NULL. 1931 * (Only if @c kind is 'text', else undefined.) */ 1932 const char *mime_type; 1933 1934 /** If not NULL, an open working copy access baton to either the 1935 * path itself (if @c path is a directory), or to the parent 1936 * directory (if @c path is a file.) 1937 * For a tree conflict, this will always be an access baton 1938 * to the parent directory of the path, even if the path is 1939 * a directory. */ 1940 svn_wc_adm_access_t *access; 1941 1942 /** The action being attempted on the conflicted node or property. 1943 * (When @c kind is 'text', this action must be 'edit'.) */ 1944 svn_wc_conflict_action_t action; 1945 1946 /** The state of the target node or property, relative to its merge-left 1947 * source, that is the reason for the conflict. 1948 * (When @c kind is 'text', this reason must be 'edited'.) */ 1949 svn_wc_conflict_reason_t reason; 1950 1951 /** If this is text-conflict and involves the merging of two files 1952 * descended from a common ancestor, here are the paths of up to 1953 * four fulltext files that can be used to interactively resolve the 1954 * conflict. All four files will be in repository-normal form -- LF 1955 * line endings and contracted keywords. (If any of these files are 1956 * not available, they default to NULL.) 1957 * 1958 * On the other hand, if this is a property-conflict, then these 1959 * paths represent temporary files that contain the three different 1960 * property-values in conflict. The fourth path (@c merged_file) 1961 * may or may not be NULL; if set, it represents libsvn_wc's 1962 * attempt to merge the property values together. (Remember that 1963 * property values are technically binary values, and thus can't 1964 * always be merged.) 1965 */ 1966 const char *base_file; /* common ancestor of the two files being merged */ 1967 1968 /** their version of the file */ 1969 const char *their_file; 1970 1971 /** my locally-edited version of the file */ 1972 const char *my_file; 1973 1974 /** merged version; may contain conflict markers */ 1975 const char *merged_file; 1976 1977 /** The operation that exposed the conflict. 1978 * Used only for tree conflicts. 1979 * 1980 * @since New in 1.6. 1981 */ 1982 svn_wc_operation_t operation; 1983 1984 /** Info on the "merge-left source" or "older" version of incoming change. 1985 * @since New in 1.6. */ 1986 svn_wc_conflict_version_t *src_left_version; 1987 1988 /** Info on the "merge-right source" or "their" version of incoming change. 1989 * @since New in 1.6. */ 1990 svn_wc_conflict_version_t *src_right_version; 1991 1992} svn_wc_conflict_description_t; 1993 1994/** 1995 * Allocate an #svn_wc_conflict_description2_t structure in @a result_pool, 1996 * initialize to represent a text conflict, and return it. 1997 * 1998 * Set the @c local_abspath field of the created struct to @a local_abspath 1999 * (which must be an absolute path), the @c kind field to 2000 * #svn_wc_conflict_kind_text, the @c node_kind to #svn_node_file, 2001 * the @c action to #svn_wc_conflict_action_edit, and the @c reason to 2002 * #svn_wc_conflict_reason_edited. 2003 * 2004 * @note It is the caller's responsibility to set the other required fields 2005 * (such as the four file names and @c mime_type and @c is_binary). 2006 * 2007 * @since New in 1.7. 2008 */ 2009svn_wc_conflict_description2_t * 2010svn_wc_conflict_description_create_text2(const char *local_abspath, 2011 apr_pool_t *result_pool); 2012 2013 2014/** Similar to svn_wc_conflict_description_create_text2(), but returns 2015 * a #svn_wc_conflict_description_t *. 2016 * 2017 * @since New in 1.6. 2018 * @deprecated Provided for backward compatibility with the 1.6 API. 2019 */ 2020SVN_DEPRECATED 2021svn_wc_conflict_description_t * 2022svn_wc_conflict_description_create_text(const char *path, 2023 svn_wc_adm_access_t *adm_access, 2024 apr_pool_t *pool); 2025 2026/** 2027 * Allocate an #svn_wc_conflict_description2_t structure in @a result_pool, 2028 * initialize to represent a property conflict, and return it. 2029 * 2030 * Set the @c local_abspath field of the created struct to @a local_abspath 2031 * (which must be an absolute path), the @c kind field 2032 * to #svn_wc_conflict_kind_property, the @c node_kind to @a node_kind, and 2033 * the @c property_name to @a property_name. 2034 * 2035 * @note: It is the caller's responsibility to set the other required fields 2036 * (such as the four file names and @c action and @c reason). 2037 * 2038 * @since New in 1.7. 2039 */ 2040svn_wc_conflict_description2_t * 2041svn_wc_conflict_description_create_prop2(const char *local_abspath, 2042 svn_node_kind_t node_kind, 2043 const char *property_name, 2044 apr_pool_t *result_pool); 2045 2046/** Similar to svn_wc_conflict_descriptor_create_prop(), but returns 2047 * a #svn_wc_conflict_description_t *. 2048 * 2049 * @since New in 1.6. 2050 * @deprecated Provided for backward compatibility with the 1.6 API. 2051 */ 2052SVN_DEPRECATED 2053svn_wc_conflict_description_t * 2054svn_wc_conflict_description_create_prop(const char *path, 2055 svn_wc_adm_access_t *adm_access, 2056 svn_node_kind_t node_kind, 2057 const char *property_name, 2058 apr_pool_t *pool); 2059 2060/** 2061 * Allocate an #svn_wc_conflict_description2_t structure in @a pool, 2062 * initialize to represent a tree conflict, and return it. 2063 * 2064 * Set the @c local_abspath field of the created struct to @a local_abspath 2065 * (which must be an absolute path), the @c kind field to 2066 * #svn_wc_conflict_kind_tree, the @c local_node_kind to @a local_node_kind, 2067 * the @c operation to @a operation, the @c src_left_version field to 2068 * @a src_left_version, and the @c src_right_version field to 2069 * @a src_right_version. 2070 * 2071 * @note: It is the caller's responsibility to set the other required fields 2072 * (such as the four file names and @c action and @c reason). 2073 * 2074 * @since New in 1.7. 2075 */ 2076svn_wc_conflict_description2_t * 2077svn_wc_conflict_description_create_tree2( 2078 const char *local_abspath, 2079 svn_node_kind_t node_kind, 2080 svn_wc_operation_t operation, 2081 const svn_wc_conflict_version_t *src_left_version, 2082 const svn_wc_conflict_version_t *src_right_version, 2083 apr_pool_t *result_pool); 2084 2085 2086/** Similar to svn_wc_conflict_description_create_tree(), but returns 2087 * a #svn_wc_conflict_description_t *. 2088 * 2089 * @since New in 1.6. 2090 * @deprecated Provided for backward compatibility with the 1.6 API. 2091 */ 2092SVN_DEPRECATED 2093svn_wc_conflict_description_t * 2094svn_wc_conflict_description_create_tree( 2095 const char *path, 2096 svn_wc_adm_access_t *adm_access, 2097 svn_node_kind_t node_kind, 2098 svn_wc_operation_t operation, 2099 /* non-const */ svn_wc_conflict_version_t *src_left_version, 2100 /* non-const */ svn_wc_conflict_version_t *src_right_version, 2101 apr_pool_t *pool); 2102 2103 2104/** Return a duplicate of @a conflict, allocated in @a result_pool. 2105 * A deep copy of all members will be made. 2106 * 2107 * @since New in 1.9. 2108 */ 2109svn_wc_conflict_description2_t * 2110svn_wc_conflict_description2_dup( 2111 const svn_wc_conflict_description2_t *conflict, 2112 apr_pool_t *result_pool); 2113 2114 2115/** Like svn_wc_conflict_description2_dup(), but is improperly named 2116 * as a private function when it is intended to be a public API. 2117 * 2118 * @since New in 1.7. 2119 * @deprecated Provided for backward compatibility with the 1.8 API. 2120 */ 2121SVN_DEPRECATED 2122svn_wc_conflict_description2_t * 2123svn_wc__conflict_description2_dup( 2124 const svn_wc_conflict_description2_t *conflict, 2125 apr_pool_t *result_pool); 2126 2127 2128/** The way in which the conflict callback chooses a course of action. 2129 * 2130 * @since New in 1.5. 2131 */ 2132typedef enum svn_wc_conflict_choice_t 2133{ 2134 /** Undefined; for internal use only. 2135 This value is never returned in svn_wc_conflict_result_t. 2136 * @since New in 1.9 2137 */ 2138 svn_wc_conflict_choose_undefined = -1, 2139 2140 /** Don't resolve the conflict now. Let libsvn_wc mark the path 2141 'conflicted', so user can run 'svn resolved' later. */ 2142 svn_wc_conflict_choose_postpone = 0, 2143 2144 /** If there were files to choose from, select one as a way of 2145 resolving the conflict here and now. libsvn_wc will then do the 2146 work of "installing" the chosen file. 2147 */ 2148 svn_wc_conflict_choose_base, /**< original version */ 2149 svn_wc_conflict_choose_theirs_full, /**< incoming version */ 2150 svn_wc_conflict_choose_mine_full, /**< own version */ 2151 svn_wc_conflict_choose_theirs_conflict, /**< incoming (for conflicted hunks) */ 2152 svn_wc_conflict_choose_mine_conflict, /**< own (for conflicted hunks) */ 2153 svn_wc_conflict_choose_merged, /**< merged version */ 2154 2155 /** @since New in 1.8. */ 2156 svn_wc_conflict_choose_unspecified /**< undecided */ 2157 2158} svn_wc_conflict_choice_t; 2159 2160 2161/** The final result returned by #svn_wc_conflict_resolver_func_t. 2162 * 2163 * @note Fields may be added to the end of this structure in future 2164 * versions. Therefore, to preserve binary compatibility, users 2165 * should not directly allocate structures of this type. Instead, 2166 * construct this structure using svn_wc_create_conflict_result() 2167 * below. 2168 * 2169 * @since New in 1.5. 2170 */ 2171typedef struct svn_wc_conflict_result_t 2172{ 2173 /** A choice to either delay the conflict resolution or select a 2174 particular file to resolve the conflict. */ 2175 svn_wc_conflict_choice_t choice; 2176 2177 /** If not NULL, this is a path to a file which contains the client's 2178 (or more likely, the user's) merging of the three values in 2179 conflict. libsvn_wc accepts this file if (and only if) @c choice 2180 is set to #svn_wc_conflict_choose_merged.*/ 2181 const char *merged_file; 2182 2183 /** If true, save a backup copy of merged_file (or the original 2184 merged_file from the conflict description, if merged_file is 2185 NULL) in the user's working copy. */ 2186 svn_boolean_t save_merged; 2187 2188 /** If not NULL, this is the new merged property, used when choosing 2189 * #svn_wc_conflict_choose_merged. This value is prefered over using 2190 * merged_file. 2191 * 2192 * @since New in 1.9. 2193 */ 2194 const svn_string_t *merged_value; 2195 2196} svn_wc_conflict_result_t; 2197 2198 2199/** 2200 * Allocate an #svn_wc_conflict_result_t structure in @a pool, 2201 * initialize and return it. 2202 * 2203 * Set the @c choice field of the structure to @a choice, @c merged_file 2204 * to @a merged_file, and @c save_merged to false. Make only a shallow 2205 * copy of the pointer argument @a merged_file. @a merged_file may be 2206 * NULL if setting merged_file is not needed. 2207 * 2208 * @since New in 1.5. 2209 */ 2210svn_wc_conflict_result_t * 2211svn_wc_create_conflict_result(svn_wc_conflict_choice_t choice, 2212 const char *merged_file, 2213 apr_pool_t *pool); 2214 2215 2216/** A callback used in merge, update and switch for resolving conflicts 2217 * during the application of a tree delta to a working copy. 2218 * 2219 * @a description describes the exact nature of the conflict, and 2220 * provides information to help resolve it. @a baton is a closure 2221 * object; it should be provided by the implementation, and passed by 2222 * the caller. When finished, the callback signals its resolution by 2223 * returning a structure in @a *result, which should be allocated in 2224 * @a result_pool. (See #svn_wc_conflict_result_t.) @a scratch_pool 2225 * should be used for any temporary allocations. 2226 * 2227 * The values #svn_wc_conflict_choose_mine_conflict and 2228 * #svn_wc_conflict_choose_theirs_conflict are not legal for conflicts 2229 * in binary files or binary properties. 2230 * 2231 * Implementations of this callback are free to present the conflict 2232 * using any user interface. This may include simple contextual 2233 * conflicts in a file's text or properties, or more complex 2234 * 'tree'-based conflicts related to obstructed additions, deletions, 2235 * and edits. The callback implementation is free to decide which 2236 * sorts of conflicts to handle; it's also free to decide which types 2237 * of conflicts are automatically resolvable and which require user 2238 * interaction. 2239 * 2240 * @since New in 1.7. 2241 */ 2242typedef svn_error_t *(*svn_wc_conflict_resolver_func2_t)( 2243 svn_wc_conflict_result_t **result, 2244 const svn_wc_conflict_description2_t *description, 2245 void *baton, 2246 apr_pool_t *result_pool, 2247 apr_pool_t *scratch_pool); 2248 2249 2250/** Similar to #svn_wc_conflict_resolver_func2_t, but using 2251 * #svn_wc_conflict_description_t instead of 2252 * #svn_wc_conflict_description2_t 2253 * 2254 * @since New in 1.5. 2255 * @deprecated Provided for backward compatibility with the 1.6 API. 2256 */ 2257typedef svn_error_t *(*svn_wc_conflict_resolver_func_t)( 2258 svn_wc_conflict_result_t **result, 2259 const svn_wc_conflict_description_t *description, 2260 void *baton, 2261 apr_pool_t *pool); 2262 2263/** @} */ 2264 2265 2266 2267/** 2268 * A callback vtable invoked by our diff-editors, as they receive diffs 2269 * from the server. 'svn diff' and 'svn merge' implement their own versions 2270 * of this vtable. 2271 * 2272 * Common parameters: 2273 * 2274 * If @a state is non-NULL, set @a *state to the state of the item 2275 * after the operation has been performed. (In practice, this is only 2276 * useful with merge, not diff; diff callbacks will probably set 2277 * @a *state to #svn_wc_notify_state_unknown, since they do not change 2278 * the state and therefore do not bother to know the state after the 2279 * operation.) By default, @a state refers to the item's content 2280 * state. Functions concerned with property state have separate 2281 * @a contentstate and @a propstate arguments. 2282 * 2283 * If @a tree_conflicted is non-NULL, set @a *tree_conflicted to true if 2284 * this operation caused a tree conflict, else to false. (Like with @a 2285 * state, this is only useful with merge, not diff; diff callbacks 2286 * should set this to false.) 2287 * 2288 * @since New in 1.7. 2289 */ 2290typedef struct svn_wc_diff_callbacks4_t 2291{ 2292 /** 2293 * This function is called before @a file_changed to allow callbacks to 2294 * skip the most expensive processing of retrieving the file data. 2295 * 2296 */ 2297 svn_error_t *(*file_opened)(svn_boolean_t *tree_conflicted, 2298 svn_boolean_t *skip, 2299 const char *path, 2300 svn_revnum_t rev, 2301 void *diff_baton, 2302 apr_pool_t *scratch_pool); 2303 2304 /** 2305 * A file @a path has changed. If @a tmpfile2 is non-NULL, the 2306 * contents have changed and those changes can be seen by comparing 2307 * @a tmpfile1 and @a tmpfile2, which represent @a rev1 and @a rev2 of 2308 * the file, respectively. 2309 * 2310 * If known, the @c svn:mime-type value of each file is passed into 2311 * @a mimetype1 and @a mimetype2; either or both of the values can 2312 * be NULL. The implementor can use this information to decide if 2313 * (or how) to generate differences. 2314 * 2315 * @a propchanges is an array of (#svn_prop_t) structures. If it contains 2316 * any elements, the original list of properties is provided in 2317 * @a originalprops, which is a hash of #svn_string_t values, keyed on the 2318 * property name. 2319 * 2320 */ 2321 svn_error_t *(*file_changed)(svn_wc_notify_state_t *contentstate, 2322 svn_wc_notify_state_t *propstate, 2323 svn_boolean_t *tree_conflicted, 2324 const char *path, 2325 const char *tmpfile1, 2326 const char *tmpfile2, 2327 svn_revnum_t rev1, 2328 svn_revnum_t rev2, 2329 const char *mimetype1, 2330 const char *mimetype2, 2331 const apr_array_header_t *propchanges, 2332 apr_hash_t *originalprops, 2333 void *diff_baton, 2334 apr_pool_t *scratch_pool); 2335 2336 /** 2337 * A file @a path was added. The contents can be seen by comparing 2338 * @a tmpfile1 and @a tmpfile2, which represent @a rev1 and @a rev2 2339 * of the file, respectively. (If either file is empty, the rev 2340 * will be 0.) 2341 * 2342 * If known, the @c svn:mime-type value of each file is passed into 2343 * @a mimetype1 and @a mimetype2; either or both of the values can 2344 * be NULL. The implementor can use this information to decide if 2345 * (or how) to generate differences. 2346 * 2347 * @a propchanges is an array of (#svn_prop_t) structures. If it contains 2348 * any elements, the original list of properties is provided in 2349 * @a originalprops, which is a hash of #svn_string_t values, keyed on the 2350 * property name. 2351 * If @a copyfrom_path is non-@c NULL, this add has history (i.e., is a 2352 * copy), and the origin of the copy may be recorded as 2353 * @a copyfrom_path under @a copyfrom_revision. 2354 */ 2355 svn_error_t *(*file_added)(svn_wc_notify_state_t *contentstate, 2356 svn_wc_notify_state_t *propstate, 2357 svn_boolean_t *tree_conflicted, 2358 const char *path, 2359 const char *tmpfile1, 2360 const char *tmpfile2, 2361 svn_revnum_t rev1, 2362 svn_revnum_t rev2, 2363 const char *mimetype1, 2364 const char *mimetype2, 2365 const char *copyfrom_path, 2366 svn_revnum_t copyfrom_revision, 2367 const apr_array_header_t *propchanges, 2368 apr_hash_t *originalprops, 2369 void *diff_baton, 2370 apr_pool_t *scratch_pool); 2371 2372 /** 2373 * A file @a path was deleted. The [loss of] contents can be seen by 2374 * comparing @a tmpfile1 and @a tmpfile2. @a originalprops provides 2375 * the properties of the file. 2376 * ### Some existing callers include WC "entry props" in @a originalprops. 2377 * 2378 * If known, the @c svn:mime-type value of each file is passed into 2379 * @a mimetype1 and @a mimetype2; either or both of the values can 2380 * be NULL. The implementor can use this information to decide if 2381 * (or how) to generate differences. 2382 */ 2383 svn_error_t *(*file_deleted)(svn_wc_notify_state_t *state, 2384 svn_boolean_t *tree_conflicted, 2385 const char *path, 2386 const char *tmpfile1, 2387 const char *tmpfile2, 2388 const char *mimetype1, 2389 const char *mimetype2, 2390 apr_hash_t *originalprops, 2391 void *diff_baton, 2392 apr_pool_t *scratch_pool); 2393 2394 /** 2395 * A directory @a path was deleted. 2396 */ 2397 svn_error_t *(*dir_deleted)(svn_wc_notify_state_t *state, 2398 svn_boolean_t *tree_conflicted, 2399 const char *path, 2400 void *diff_baton, 2401 apr_pool_t *scratch_pool); 2402 /** 2403 * A directory @a path has been opened. @a rev is the revision that the 2404 * directory came from. 2405 * 2406 * This function is called for any existing directory @a path before any 2407 * of the callbacks are called for a child of @a path. 2408 * 2409 * If the callback returns @c TRUE in @a *skip_children, children 2410 * of this directory will be skipped. 2411 */ 2412 svn_error_t *(*dir_opened)(svn_boolean_t *tree_conflicted, 2413 svn_boolean_t *skip, 2414 svn_boolean_t *skip_children, 2415 const char *path, 2416 svn_revnum_t rev, 2417 void *diff_baton, 2418 apr_pool_t *scratch_pool); 2419 2420 /** 2421 * A directory @a path was added. @a rev is the revision that the 2422 * directory came from. 2423 * 2424 * This function is called for any new directory @a path before any 2425 * of the callbacks are called for a child of @a path. 2426 * 2427 * If @a copyfrom_path is non-@c NULL, this add has history (i.e., is a 2428 * copy), and the origin of the copy may be recorded as 2429 * @a copyfrom_path under @a copyfrom_revision. 2430 */ 2431 svn_error_t *(*dir_added)(svn_wc_notify_state_t *state, 2432 svn_boolean_t *tree_conflicted, 2433 svn_boolean_t *skip, 2434 svn_boolean_t *skip_children, 2435 const char *path, 2436 svn_revnum_t rev, 2437 const char *copyfrom_path, 2438 svn_revnum_t copyfrom_revision, 2439 void *diff_baton, 2440 apr_pool_t *scratch_pool); 2441 2442 /** 2443 * A list of property changes (@a propchanges) was applied to the 2444 * directory @a path. 2445 * 2446 * The array is a list of (#svn_prop_t) structures. 2447 * 2448 * @a dir_was_added is set to #TRUE if the directory was added, and 2449 * to #FALSE if the directory pre-existed. 2450 */ 2451 svn_error_t *(*dir_props_changed)(svn_wc_notify_state_t *propstate, 2452 svn_boolean_t *tree_conflicted, 2453 const char *path, 2454 svn_boolean_t dir_was_added, 2455 const apr_array_header_t *propchanges, 2456 apr_hash_t *original_props, 2457 void *diff_baton, 2458 apr_pool_t *scratch_pool); 2459 2460 /** 2461 * A directory @a path which has been opened with @a dir_opened or @a 2462 * dir_added has been closed. 2463 * 2464 * @a dir_was_added is set to #TRUE if the directory was added, and 2465 * to #FALSE if the directory pre-existed. 2466 */ 2467 svn_error_t *(*dir_closed)(svn_wc_notify_state_t *contentstate, 2468 svn_wc_notify_state_t *propstate, 2469 svn_boolean_t *tree_conflicted, 2470 const char *path, 2471 svn_boolean_t dir_was_added, 2472 void *diff_baton, 2473 apr_pool_t *scratch_pool); 2474 2475} svn_wc_diff_callbacks4_t; 2476 2477 2478/** 2479 * Similar to #svn_wc_diff_callbacks4_t, but without @a copyfrom_path and 2480 * @a copyfrom_revision arguments to @c file_added and @c dir_added functions. 2481 * 2482 * @since New in 1.6. 2483 * @deprecated Provided for backward compatibility with the 1.6 API. 2484 */ 2485typedef struct svn_wc_diff_callbacks3_t 2486{ 2487 /** The same as #svn_wc_diff_callbacks4_t.file_changed. */ 2488 svn_error_t *(*file_changed)(svn_wc_adm_access_t *adm_access, 2489 svn_wc_notify_state_t *contentstate, 2490 svn_wc_notify_state_t *propstate, 2491 svn_boolean_t *tree_conflicted, 2492 const char *path, 2493 const char *tmpfile1, 2494 const char *tmpfile2, 2495 svn_revnum_t rev1, 2496 svn_revnum_t rev2, 2497 const char *mimetype1, 2498 const char *mimetype2, 2499 const apr_array_header_t *propchanges, 2500 apr_hash_t *originalprops, 2501 void *diff_baton); 2502 2503 /** Similar to #svn_wc_diff_callbacks4_t.file_added but without 2504 * @a copyfrom_path and @a copyfrom_revision arguments. */ 2505 svn_error_t *(*file_added)(svn_wc_adm_access_t *adm_access, 2506 svn_wc_notify_state_t *contentstate, 2507 svn_wc_notify_state_t *propstate, 2508 svn_boolean_t *tree_conflicted, 2509 const char *path, 2510 const char *tmpfile1, 2511 const char *tmpfile2, 2512 svn_revnum_t rev1, 2513 svn_revnum_t rev2, 2514 const char *mimetype1, 2515 const char *mimetype2, 2516 const apr_array_header_t *propchanges, 2517 apr_hash_t *originalprops, 2518 void *diff_baton); 2519 2520 /** The same as #svn_wc_diff_callbacks4_t.file_deleted. */ 2521 svn_error_t *(*file_deleted)(svn_wc_adm_access_t *adm_access, 2522 svn_wc_notify_state_t *state, 2523 svn_boolean_t *tree_conflicted, 2524 const char *path, 2525 const char *tmpfile1, 2526 const char *tmpfile2, 2527 const char *mimetype1, 2528 const char *mimetype2, 2529 apr_hash_t *originalprops, 2530 void *diff_baton); 2531 2532 /** Similar to #svn_wc_diff_callbacks4_t.dir_added but without 2533 * @a copyfrom_path and @a copyfrom_revision arguments. */ 2534 svn_error_t *(*dir_added)(svn_wc_adm_access_t *adm_access, 2535 svn_wc_notify_state_t *state, 2536 svn_boolean_t *tree_conflicted, 2537 const char *path, 2538 svn_revnum_t rev, 2539 void *diff_baton); 2540 2541 /** The same as #svn_wc_diff_callbacks4_t.dir_deleted. */ 2542 svn_error_t *(*dir_deleted)(svn_wc_adm_access_t *adm_access, 2543 svn_wc_notify_state_t *state, 2544 svn_boolean_t *tree_conflicted, 2545 const char *path, 2546 void *diff_baton); 2547 2548 /** The same as #svn_wc_diff_callbacks4_t.dir_props_changed. */ 2549 svn_error_t *(*dir_props_changed)(svn_wc_adm_access_t *adm_access, 2550 svn_wc_notify_state_t *propstate, 2551 svn_boolean_t *tree_conflicted, 2552 const char *path, 2553 const apr_array_header_t *propchanges, 2554 apr_hash_t *original_props, 2555 void *diff_baton); 2556 2557 /** The same as #svn_wc_diff_callbacks4_t.dir_opened. */ 2558 svn_error_t *(*dir_opened)(svn_wc_adm_access_t *adm_access, 2559 svn_boolean_t *tree_conflicted, 2560 const char *path, 2561 svn_revnum_t rev, 2562 void *diff_baton); 2563 2564 /** The same as #svn_wc_diff_callbacks4_t.dir_closed. */ 2565 svn_error_t *(*dir_closed)(svn_wc_adm_access_t *adm_access, 2566 svn_wc_notify_state_t *contentstate, 2567 svn_wc_notify_state_t *propstate, 2568 svn_boolean_t *tree_conflicted, 2569 const char *path, 2570 void *diff_baton); 2571 2572} svn_wc_diff_callbacks3_t; 2573 2574/** 2575 * Similar to #svn_wc_diff_callbacks3_t, but without the @c dir_opened 2576 * and @c dir_closed functions, and without the @a tree_conflicted argument 2577 * to the functions. 2578 * 2579 * @deprecated Provided for backward compatibility with the 1.2 API. 2580 */ 2581typedef struct svn_wc_diff_callbacks2_t 2582{ 2583 /** The same as @c file_changed in #svn_wc_diff_callbacks3_t. */ 2584 svn_error_t *(*file_changed)(svn_wc_adm_access_t *adm_access, 2585 svn_wc_notify_state_t *contentstate, 2586 svn_wc_notify_state_t *propstate, 2587 const char *path, 2588 const char *tmpfile1, 2589 const char *tmpfile2, 2590 svn_revnum_t rev1, 2591 svn_revnum_t rev2, 2592 const char *mimetype1, 2593 const char *mimetype2, 2594 const apr_array_header_t *propchanges, 2595 apr_hash_t *originalprops, 2596 void *diff_baton); 2597 2598 /** The same as @c file_added in #svn_wc_diff_callbacks3_t. */ 2599 svn_error_t *(*file_added)(svn_wc_adm_access_t *adm_access, 2600 svn_wc_notify_state_t *contentstate, 2601 svn_wc_notify_state_t *propstate, 2602 const char *path, 2603 const char *tmpfile1, 2604 const char *tmpfile2, 2605 svn_revnum_t rev1, 2606 svn_revnum_t rev2, 2607 const char *mimetype1, 2608 const char *mimetype2, 2609 const apr_array_header_t *propchanges, 2610 apr_hash_t *originalprops, 2611 void *diff_baton); 2612 2613 /** The same as @c file_deleted in #svn_wc_diff_callbacks3_t. */ 2614 svn_error_t *(*file_deleted)(svn_wc_adm_access_t *adm_access, 2615 svn_wc_notify_state_t *state, 2616 const char *path, 2617 const char *tmpfile1, 2618 const char *tmpfile2, 2619 const char *mimetype1, 2620 const char *mimetype2, 2621 apr_hash_t *originalprops, 2622 void *diff_baton); 2623 2624 /** The same as @c dir_added in #svn_wc_diff_callbacks3_t. */ 2625 svn_error_t *(*dir_added)(svn_wc_adm_access_t *adm_access, 2626 svn_wc_notify_state_t *state, 2627 const char *path, 2628 svn_revnum_t rev, 2629 void *diff_baton); 2630 2631 /** The same as @c dir_deleted in #svn_wc_diff_callbacks3_t. */ 2632 svn_error_t *(*dir_deleted)(svn_wc_adm_access_t *adm_access, 2633 svn_wc_notify_state_t *state, 2634 const char *path, 2635 void *diff_baton); 2636 2637 /** The same as @c dir_props_changed in #svn_wc_diff_callbacks3_t. */ 2638 svn_error_t *(*dir_props_changed)(svn_wc_adm_access_t *adm_access, 2639 svn_wc_notify_state_t *state, 2640 const char *path, 2641 const apr_array_header_t *propchanges, 2642 apr_hash_t *original_props, 2643 void *diff_baton); 2644 2645} svn_wc_diff_callbacks2_t; 2646 2647/** 2648 * Similar to #svn_wc_diff_callbacks2_t, but with file additions/content 2649 * changes and property changes split into different functions. 2650 * 2651 * @deprecated Provided for backward compatibility with the 1.1 API. 2652 */ 2653typedef struct svn_wc_diff_callbacks_t 2654{ 2655 /** Similar to @c file_changed in #svn_wc_diff_callbacks2_t, but without 2656 * property change information. @a tmpfile2 is never NULL. @a state applies 2657 * to the file contents. */ 2658 svn_error_t *(*file_changed)(svn_wc_adm_access_t *adm_access, 2659 svn_wc_notify_state_t *state, 2660 const char *path, 2661 const char *tmpfile1, 2662 const char *tmpfile2, 2663 svn_revnum_t rev1, 2664 svn_revnum_t rev2, 2665 const char *mimetype1, 2666 const char *mimetype2, 2667 void *diff_baton); 2668 2669 /** Similar to @c file_added in #svn_wc_diff_callbacks2_t, but without 2670 * property change information. @a *state applies to the file contents. */ 2671 svn_error_t *(*file_added)(svn_wc_adm_access_t *adm_access, 2672 svn_wc_notify_state_t *state, 2673 const char *path, 2674 const char *tmpfile1, 2675 const char *tmpfile2, 2676 svn_revnum_t rev1, 2677 svn_revnum_t rev2, 2678 const char *mimetype1, 2679 const char *mimetype2, 2680 void *diff_baton); 2681 2682 /** Similar to @c file_deleted in #svn_wc_diff_callbacks2_t, but without 2683 * the properties. */ 2684 svn_error_t *(*file_deleted)(svn_wc_adm_access_t *adm_access, 2685 svn_wc_notify_state_t *state, 2686 const char *path, 2687 const char *tmpfile1, 2688 const char *tmpfile2, 2689 const char *mimetype1, 2690 const char *mimetype2, 2691 void *diff_baton); 2692 2693 /** The same as @c dir_added in #svn_wc_diff_callbacks2_t. */ 2694 svn_error_t *(*dir_added)(svn_wc_adm_access_t *adm_access, 2695 svn_wc_notify_state_t *state, 2696 const char *path, 2697 svn_revnum_t rev, 2698 void *diff_baton); 2699 2700 /** The same as @c dir_deleted in #svn_wc_diff_callbacks2_t. */ 2701 svn_error_t *(*dir_deleted)(svn_wc_adm_access_t *adm_access, 2702 svn_wc_notify_state_t *state, 2703 const char *path, 2704 void *diff_baton); 2705 2706 /** Similar to @c dir_props_changed in #svn_wc_diff_callbacks2_t, but this 2707 * function is called for files as well as directories. */ 2708 svn_error_t *(*props_changed)(svn_wc_adm_access_t *adm_access, 2709 svn_wc_notify_state_t *state, 2710 const char *path, 2711 const apr_array_header_t *propchanges, 2712 apr_hash_t *original_props, 2713 void *diff_baton); 2714 2715} svn_wc_diff_callbacks_t; 2716 2717 2718/* Asking questions about a working copy. */ 2719 2720/** Set @a *wc_format to @a local_abspath's working copy format version 2721 * number if @a local_abspath is a valid working copy directory, else set it 2722 * to 0. 2723 * 2724 * Return error @c APR_ENOENT if @a local_abspath does not exist at all. 2725 * 2726 * @since New in 1.7. 2727 */ 2728svn_error_t * 2729svn_wc_check_wc2(int *wc_format, 2730 svn_wc_context_t *wc_ctx, 2731 const char *local_abspath, 2732 apr_pool_t *scratch_pool); 2733 2734/** 2735 * Similar to svn_wc_check_wc2(), but with a relative path and no supplied 2736 * working copy context. 2737 * 2738 * @deprecated Provided for backward compatibility with the 1.6 API. 2739 */ 2740SVN_DEPRECATED 2741svn_error_t * 2742svn_wc_check_wc(const char *path, 2743 int *wc_format, 2744 apr_pool_t *pool); 2745 2746 2747/** Set @a *has_binary_prop to @c TRUE iff @a path has been marked 2748 * with a property indicating that it is non-text (in other words, binary). 2749 * @a adm_access is an access baton set that contains @a path. 2750 * 2751 * @deprecated Provided for backward compatibility with the 1.6 API. As a 2752 * replacement for this functionality, @see svn_mime_type_is_binary and 2753 * #SVN_PROP_MIME_TYPE. 2754 */ 2755SVN_DEPRECATED 2756svn_error_t * 2757svn_wc_has_binary_prop(svn_boolean_t *has_binary_prop, 2758 const char *path, 2759 svn_wc_adm_access_t *adm_access, 2760 apr_pool_t *pool); 2761 2762 2763/* Detecting modification. */ 2764 2765/** Set @a *modified_p to non-zero if @a local_abspath's text is modified 2766 * with regard to the base revision, else set @a *modified_p to zero. 2767 * @a local_abspath is the absolute path to the file. 2768 * 2769 * This function uses some heuristics to avoid byte-by-byte comparisons 2770 * against the base text (eg. file size and its modification time). 2771 * 2772 * If @a local_abspath does not exist, consider it unmodified. If it exists 2773 * but is not under revision control (not even scheduled for 2774 * addition), return the error #SVN_ERR_ENTRY_NOT_FOUND. 2775 * 2776 * @a unused is ignored. 2777 * 2778 * @since New in 1.7. 2779 */ 2780svn_error_t * 2781svn_wc_text_modified_p2(svn_boolean_t *modified_p, 2782 svn_wc_context_t *wc_ctx, 2783 const char *local_abspath, 2784 svn_boolean_t unused, 2785 apr_pool_t *scratch_pool); 2786 2787/** Similar to svn_wc_text_modified_p2(), but with a relative path and 2788 * adm_access baton? 2789 * 2790 * @deprecated Provided for backward compatibility with the 1.6 API. 2791 */ 2792SVN_DEPRECATED 2793svn_error_t * 2794svn_wc_text_modified_p(svn_boolean_t *modified_p, 2795 const char *filename, 2796 svn_boolean_t force_comparison, 2797 svn_wc_adm_access_t *adm_access, 2798 apr_pool_t *pool); 2799 2800/** Set @a *modified_p to non-zero if @a path's properties are modified 2801 * with regard to the base revision, else set @a modified_p to zero. 2802 * @a adm_access must be an access baton for @a path. 2803 * 2804 * @since New in 1.7. 2805 */ 2806svn_error_t * 2807svn_wc_props_modified_p2(svn_boolean_t *modified_p, 2808 svn_wc_context_t *wc_ctx, 2809 const char *local_abspath, 2810 apr_pool_t *scratch_pool); 2811 2812/** Similar to svn_wc_props_modified_p2(), but with a relative path and 2813 * adm_access baton. 2814 * 2815 * @deprecated Provided for backward compatibility with the 1.6 API. 2816 */ 2817SVN_DEPRECATED 2818svn_error_t * 2819svn_wc_props_modified_p(svn_boolean_t *modified_p, 2820 const char *path, 2821 svn_wc_adm_access_t *adm_access, 2822 apr_pool_t *pool); 2823 2824 2825/** 2826* @defgroup svn_wc_entries Entries and status (deprecated) 2827 * @{ 2828 */ 2829 2830/** The schedule states an entry can be in. 2831 * @deprecated Provided for backward compatibility with the 1.6 API. */ 2832typedef enum svn_wc_schedule_t 2833{ 2834 /** Nothing special here */ 2835 svn_wc_schedule_normal, 2836 2837 /** Slated for addition */ 2838 svn_wc_schedule_add, 2839 2840 /** Slated for deletion */ 2841 svn_wc_schedule_delete, 2842 2843 /** Slated for replacement (delete + add) */ 2844 svn_wc_schedule_replace 2845 2846} svn_wc_schedule_t; 2847 2848 2849/** 2850 * Values for the working_size field in svn_wc_entry_t 2851 * when it isn't set to the actual size value of the unchanged 2852 * working file. 2853 * 2854 * The value of the working size is unknown (hasn't been 2855 * calculated and stored in the past for whatever reason). 2856 * 2857 * @since New in 1.5 2858 * @deprecated Provided for backward compatibility with the 1.6 API. 2859 */ 2860#define SVN_WC_ENTRY_WORKING_SIZE_UNKNOWN (-1) 2861 2862/** A working copy entry -- that is, revision control information about 2863 * one versioned entity. 2864 * 2865 * @deprecated Provided for backward compatibility with the 1.6 API. 2866 */ 2867/* SVN_DEPRECATED */ 2868typedef struct svn_wc_entry_t 2869{ 2870 /* IMPORTANT: If you extend this structure, add new fields to the end. */ 2871 2872 /* General Attributes */ 2873 2874 /** entry's name */ 2875 const char *name; 2876 2877 /** base revision */ 2878 svn_revnum_t revision; 2879 2880 /** url in repository */ 2881 const char *url; 2882 2883 /** canonical repository URL or NULL if not known */ 2884 const char *repos; 2885 2886 /** repository uuid */ 2887 const char *uuid; 2888 2889 /** node kind (file, dir, ...) */ 2890 svn_node_kind_t kind; 2891 2892 /* State information */ 2893 2894 /** scheduling (add, delete, replace ...) */ 2895 svn_wc_schedule_t schedule; 2896 2897 /** in a copied state (possibly because the entry is a child of a 2898 * path that is #svn_wc_schedule_add or #svn_wc_schedule_replace, 2899 * when the entry itself is #svn_wc_schedule_normal). 2900 * COPIED is true for nodes under a directory that was copied, but 2901 * COPYFROM_URL is null there. They are both set for the root 2902 * destination of the copy. 2903 */ 2904 svn_boolean_t copied; 2905 2906 /** The directory containing this entry had a versioned child of this 2907 * name, but this entry represents a different revision or a switched 2908 * path at which no item exists in the repository. This typically 2909 * arises from committing or updating to a deletion of this entry 2910 * without committing or updating the parent directory. 2911 * 2912 * The schedule can be 'normal' or 'add'. */ 2913 svn_boolean_t deleted; 2914 2915 /** absent -- we know an entry of this name exists, but that's all 2916 (usually this happens because of authz restrictions) */ 2917 svn_boolean_t absent; 2918 2919 /** for THIS_DIR entry, implies whole entries file is incomplete */ 2920 svn_boolean_t incomplete; 2921 2922 /** copyfrom location */ 2923 const char *copyfrom_url; 2924 2925 /** copyfrom revision */ 2926 svn_revnum_t copyfrom_rev; 2927 2928 /** old version of conflicted file. A file basename, relative to the 2929 * user's directory that the THIS_DIR entry refers to. */ 2930 const char *conflict_old; 2931 2932 /** new version of conflicted file. A file basename, relative to the 2933 * user's directory that the THIS_DIR entry refers to. */ 2934 const char *conflict_new; 2935 2936 /** working version of conflicted file. A file basename, relative to the 2937 * user's directory that the THIS_DIR entry refers to. */ 2938 const char *conflict_wrk; 2939 2940 /** property reject file. A file basename, relative to the user's 2941 * directory that the THIS_DIR entry refers to. */ 2942 const char *prejfile; 2943 2944 /** last up-to-date time for text contents (0 means no information available) 2945 */ 2946 apr_time_t text_time; 2947 2948 /** last up-to-date time for properties (0 means no information available) 2949 * 2950 * @deprecated This value will always be 0 in version 1.4 and later. 2951 */ 2952 apr_time_t prop_time; 2953 2954 /** Hex MD5 checksum for the untranslated text base file, 2955 * can be @c NULL for backwards compatibility. 2956 */ 2957 const char *checksum; 2958 2959 /* "Entry props" */ 2960 2961 /** last revision this was changed */ 2962 svn_revnum_t cmt_rev; 2963 2964 /** last date this was changed */ 2965 apr_time_t cmt_date; 2966 2967 /** last commit author of this item */ 2968 const char *cmt_author; 2969 2970 /** lock token or NULL if path not locked in this WC 2971 * @since New in 1.2. 2972 */ 2973 const char *lock_token; 2974 2975 /** lock owner, or NULL if not locked in this WC 2976 * @since New in 1.2. 2977 */ 2978 const char *lock_owner; 2979 2980 /** lock comment or NULL if not locked in this WC or no comment 2981 * @since New in 1.2. 2982 */ 2983 const char *lock_comment; 2984 2985 /** Lock creation date or 0 if not locked in this WC 2986 * @since New in 1.2. 2987 */ 2988 apr_time_t lock_creation_date; 2989 2990 /** Whether this entry has any working properties. 2991 * False if this information is not stored in the entry. 2992 * 2993 * @since New in 1.4. */ 2994 svn_boolean_t has_props; 2995 2996 /** Whether this entry has property modifications. 2997 * 2998 * @note For working copies in older formats, this flag is not valid. 2999 * 3000 * @see svn_wc_props_modified_p(). 3001 * 3002 * @since New in 1.4. */ 3003 svn_boolean_t has_prop_mods; 3004 3005 /** A space-separated list of all properties whose presence/absence is cached 3006 * in this entry. 3007 * 3008 * @see @c present_props. 3009 * 3010 * @since New in 1.4. 3011 * @deprecated This value will always be "" in version 1.7 and later. */ 3012 const char *cachable_props; 3013 3014 /** Cached property existence for this entry. 3015 * This is a space-separated list of property names. If a name exists in 3016 * @c cachable_props but not in this list, this entry does not have that 3017 * property. If a name exists in both lists, the property is present on this 3018 * entry. 3019 * 3020 * @since New in 1.4. 3021 * @deprecated This value will always be "" in version 1.7 and later. */ 3022 const char *present_props; 3023 3024 /** which changelist this item is part of, or NULL if not part of any. 3025 * @since New in 1.5. 3026 */ 3027 const char *changelist; 3028 3029 /** Size of the file after being translated into local 3030 * representation, or #SVN_WC_ENTRY_WORKING_SIZE_UNKNOWN if 3031 * unknown. 3032 * 3033 * @since New in 1.5. 3034 */ 3035 apr_off_t working_size; 3036 3037 /** Whether a local copy of this entry should be kept in the working copy 3038 * after a deletion has been committed, Only valid for the this-dir entry 3039 * when it is scheduled for deletion. 3040 * 3041 * @since New in 1.5. */ 3042 svn_boolean_t keep_local; 3043 3044 /** The depth of this entry. 3045 * 3046 * ### It's a bit annoying that we only use this on this_dir 3047 * ### entries, yet it will exist (with value svn_depth_infinity) on 3048 * ### all entries. Maybe some future extensibility would make this 3049 * ### field meaningful on entries besides this_dir. 3050 * 3051 * @since New in 1.5. */ 3052 svn_depth_t depth; 3053 3054 /** Serialized data for all of the tree conflicts detected in this_dir. 3055 * 3056 * @since New in 1.6. */ 3057 const char *tree_conflict_data; 3058 3059 /** The entry is a intra-repository file external and this is the 3060 * repository root relative path to the file specified in the 3061 * externals definition, otherwise NULL if the entry is not a file 3062 * external. 3063 * 3064 * @since New in 1.6. */ 3065 const char *file_external_path; 3066 3067 /** The entry is a intra-repository file external and this is the 3068 * peg revision number specified in the externals definition. This 3069 * field is only valid when the file_external_path field is 3070 * non-NULL. The only permissible values are 3071 * svn_opt_revision_unspecified if the entry is not an external, 3072 * svn_opt_revision_head if the external revision is unspecified or 3073 * specified with -r HEAD or svn_opt_revision_number for a specific 3074 * revision number. 3075 * 3076 * @since New in 1.6. */ 3077 svn_opt_revision_t file_external_peg_rev; 3078 3079 /** The entry is an intra-repository file external and this is the 3080 * operative revision number specified in the externals definition. 3081 * This field is only valid when the file_external_path field is 3082 * non-NULL. The only permissible values are 3083 * svn_opt_revision_unspecified if the entry is not an external, 3084 * svn_opt_revision_head if the external revision is unspecified or 3085 * specified with -r HEAD or svn_opt_revision_number for a specific 3086 * revision number. 3087 * 3088 * @since New in 1.6. */ 3089 svn_opt_revision_t file_external_rev; 3090 3091 /* IMPORTANT: If you extend this structure, check the following functions in 3092 * subversion/libsvn_wc/entries.c, to see if you need to extend them as well. 3093 * 3094 * svn_wc__atts_to_entry() 3095 * svn_wc_entry_dup() 3096 * alloc_entry() 3097 * read_entry() 3098 * write_entry() 3099 * fold_entry() 3100 */ 3101} svn_wc_entry_t; 3102 3103 3104/** How an entries file's owner dir is named in the entries file. 3105 * @deprecated Provided for backward compatibility with the 1.6 API. */ 3106#define SVN_WC_ENTRY_THIS_DIR "" 3107 3108 3109/** Set @a *entry to an entry for @a path, allocated in the access baton pool. 3110 * If @a show_hidden is TRUE, return the entry even if it's in 'excluded', 3111 * 'deleted' or 'absent' state. Excluded entries are those with their depth 3112 * set to #svn_depth_exclude. If @a path is not under revision control, or 3113 * if entry is hidden, not scheduled for re-addition, and @a show_hidden is @c 3114 * FALSE, then set @a *entry to @c NULL. 3115 * 3116 * @a *entry should not be modified, since doing so modifies the entries 3117 * cache in @a adm_access without changing the entries file on disk. 3118 * 3119 * If @a path is not a directory then @a adm_access must be an access baton 3120 * for the parent directory of @a path. To avoid needing to know whether 3121 * @a path is a directory or not, if @a path is a directory @a adm_access 3122 * can still be an access baton for the parent of @a path so long as the 3123 * access baton for @a path itself is in the same access baton set. 3124 * 3125 * @a path can be relative or absolute but must share the same base used 3126 * to open @a adm_access. 3127 * 3128 * Note that it is possible for @a path to be absent from disk but still 3129 * under revision control; and conversely, it is possible for @a path to 3130 * be present, but not under revision control. 3131 * 3132 * Use @a pool only for local processing. 3133 * 3134 * @deprecated Provided for backward compatibility with the 1.6 API. 3135 */ 3136SVN_DEPRECATED 3137svn_error_t * 3138svn_wc_entry(const svn_wc_entry_t **entry, 3139 const char *path, 3140 svn_wc_adm_access_t *adm_access, 3141 svn_boolean_t show_hidden, 3142 apr_pool_t *pool); 3143 3144 3145/** Parse the `entries' file for @a adm_access and return a hash @a entries, 3146 * whose keys are (<tt>const char *</tt>) entry names and values are 3147 * (<tt>svn_wc_entry_t *</tt>). The hash @a entries, and its keys and 3148 * values, are allocated from the pool used to open the @a adm_access 3149 * baton (that's how the entries caching works). @a pool is used for 3150 * transient allocations. 3151 * 3152 * Entries that are in a 'excluded', 'deleted' or 'absent' state (and not 3153 * scheduled for re-addition) are not returned in the hash, unless 3154 * @a show_hidden is TRUE. Excluded entries are those with their depth set to 3155 * #svn_depth_exclude. 3156 * 3157 * @par Important: 3158 * The @a entries hash is the entries cache in @a adm_access 3159 * and so usually the hash itself, the keys and the values should be treated 3160 * as read-only. If any of these are modified then it is the caller's 3161 * responsibility to ensure that the entries file on disk is updated. Treat 3162 * the hash values as type (<tt>const svn_wc_entry_t *</tt>) if you wish to 3163 * avoid accidental modification. Modifying the schedule member is a 3164 * particularly bad idea, as the entries writing process relies on having 3165 * access to the original schedule. Use a duplicate entry to modify the 3166 * schedule. 3167 * 3168 * @par Important: 3169 * Only the entry structures representing files and 3170 * #SVN_WC_ENTRY_THIS_DIR contain complete information. The entry 3171 * structures representing subdirs have only the `kind' and `state' 3172 * fields filled in. If you want info on a subdir, you must use this 3173 * routine to open its @a path and read the #SVN_WC_ENTRY_THIS_DIR 3174 * structure, or call svn_wc_entry() on its @a path. 3175 * 3176 * @deprecated Provided for backward compatibility with the 1.6 API. 3177 */ 3178SVN_DEPRECATED 3179svn_error_t * 3180svn_wc_entries_read(apr_hash_t **entries, 3181 svn_wc_adm_access_t *adm_access, 3182 svn_boolean_t show_hidden, 3183 apr_pool_t *pool); 3184 3185 3186/** Return a duplicate of @a entry, allocated in @a pool. No part of the new 3187 * entry will be shared with @a entry. 3188 * 3189 * @deprecated Provided for backward compatibility with the 1.6 API. 3190 */ 3191SVN_DEPRECATED 3192svn_wc_entry_t * 3193svn_wc_entry_dup(const svn_wc_entry_t *entry, 3194 apr_pool_t *pool); 3195 3196/** @} */ 3197 3198 3199/** 3200 * This struct contains information about a working copy node. 3201 * 3202 * @note Fields may be added to the end of this structure in future 3203 * versions. Therefore, users shouldn't allocate structures of this 3204 * type, to preserve binary compatibility. 3205 * 3206 * @since New in 1.7. 3207 */ 3208typedef struct svn_wc_info_t 3209{ 3210 /** The schedule of this item 3211 * ### Do we still need schedule? */ 3212 svn_wc_schedule_t schedule; 3213 3214 /** If copied, the URL from which the copy was made, else @c NULL. */ 3215 const char *copyfrom_url; 3216 3217 /** If copied, the revision from which the copy was made, 3218 * else #SVN_INVALID_REVNUM. */ 3219 svn_revnum_t copyfrom_rev; 3220 3221 /** The checksum of the node, if it is a file. */ 3222 const svn_checksum_t *checksum; 3223 3224 /** A changelist the item is in, @c NULL if this node is not in a 3225 * changelist. */ 3226 const char *changelist; 3227 3228 /** The depth of the item, see #svn_depth_t */ 3229 svn_depth_t depth; 3230 3231 /** 3232 * The size of the file after being translated into its local 3233 * representation, or #SVN_INVALID_FILESIZE if unknown. 3234 * Not applicable for directories. 3235 */ 3236 svn_filesize_t recorded_size; 3237 3238 /** 3239 * The time at which the file had the recorded size recorded_size and was 3240 * considered unmodified. */ 3241 apr_time_t recorded_time; 3242 3243 /** Array of const svn_wc_conflict_description2_t * which contains info 3244 * on any conflict of which this node is a victim. Otherwise NULL. */ 3245 const apr_array_header_t *conflicts; 3246 3247 /** The local absolute path of the working copy root. */ 3248 const char *wcroot_abspath; 3249 3250 /** The path the node was moved from, if it was moved here. Else NULL. 3251 * @since New in 1.8. */ 3252 const char *moved_from_abspath; 3253 3254 /** The path the node was moved to, if it was moved away. Else NULL. 3255 * @since New in 1.8. */ 3256 const char *moved_to_abspath; 3257} svn_wc_info_t; 3258 3259/** 3260 * Return a duplicate of @a info, allocated in @a pool. No part of the new 3261 * structure will be shared with @a info. 3262 * 3263 * @since New in 1.7. 3264 */ 3265svn_wc_info_t * 3266svn_wc_info_dup(const svn_wc_info_t *info, 3267 apr_pool_t *pool); 3268 3269 3270/** Given @a local_abspath in a dir under version control, decide if it is 3271 * in a state of conflict; return the answers in @a *text_conflicted_p, @a 3272 * *prop_conflicted_p, and @a *tree_conflicted_p. If one or two of the 3273 * answers are uninteresting, simply pass @c NULL pointers for those. 3274 * 3275 * If @a local_abspath is unversioned or does not exist, return 3276 * #SVN_ERR_WC_PATH_NOT_FOUND. 3277 * 3278 * If the @a local_abspath has corresponding text conflict files (with suffix 3279 * .mine, .theirs, etc.) that cannot be found, assume that the text conflict 3280 * has been resolved by the user and return @c FALSE in @a 3281 * *text_conflicted_p. 3282 * 3283 * Similarly, if a property conflicts file (.prej suffix) is said to exist, 3284 * but it cannot be found, assume that the property conflicts have been 3285 * resolved by the user and return @c FALSE in @a *prop_conflicted_p. 3286 * 3287 * @a *tree_conflicted_p can't be auto-resolved in this fashion. An 3288 * explicit `resolved' is needed. 3289 * 3290 * @since New in 1.7. 3291 */ 3292svn_error_t * 3293svn_wc_conflicted_p3(svn_boolean_t *text_conflicted_p, 3294 svn_boolean_t *prop_conflicted_p, 3295 svn_boolean_t *tree_conflicted_p, 3296 svn_wc_context_t *wc_ctx, 3297 const char *local_abspath, 3298 apr_pool_t *scratch_pool); 3299 3300/** Similar to svn_wc_conflicted_p3(), but with a path/adm_access parameter 3301 * pair in place of a wc_ctx/local_abspath pair. 3302 * 3303 * @since New in 1.6. 3304 * @deprecated Provided for backward compatibility with the 1.6 API. 3305 */ 3306SVN_DEPRECATED 3307svn_error_t * 3308svn_wc_conflicted_p2(svn_boolean_t *text_conflicted_p, 3309 svn_boolean_t *prop_conflicted_p, 3310 svn_boolean_t *tree_conflicted_p, 3311 const char *path, 3312 svn_wc_adm_access_t *adm_access, 3313 apr_pool_t *pool); 3314 3315/** Given a @a dir_path under version control, decide if one of its entries 3316 * (@a entry) is in a state of conflict; return the answers in @a 3317 * text_conflicted_p and @a prop_conflicted_p. These pointers must not be 3318 * null. 3319 * 3320 * If the @a entry mentions that text conflict files (with suffix .mine, 3321 * .theirs, etc.) exist, but they cannot be found, assume the text conflict 3322 * has been resolved by the user and return FALSE in @a *text_conflicted_p. 3323 * 3324 * Similarly, if the @a entry mentions that a property conflicts file (.prej 3325 * suffix) exists, but it cannot be found, assume the property conflicts 3326 * have been resolved by the user and return FALSE in @a *prop_conflicted_p. 3327 * 3328 * The @a entry is not updated. 3329 * 3330 * @deprecated Provided for backward compatibility with the 1.5 API. 3331 */ 3332SVN_DEPRECATED 3333svn_error_t * 3334svn_wc_conflicted_p(svn_boolean_t *text_conflicted_p, 3335 svn_boolean_t *prop_conflicted_p, 3336 const char *dir_path, 3337 const svn_wc_entry_t *entry, 3338 apr_pool_t *pool); 3339 3340 3341/** Set @a *url and @a *rev to the ancestor URL and revision for @a path, 3342 * allocating in @a pool. @a adm_access must be an access baton for @a path. 3343 * 3344 * If @a url or @a rev is NULL, then ignore it (just don't return the 3345 * corresponding information). 3346 * 3347 * @deprecated Provided for backward compatibility with the 1.6 API. 3348 */ 3349SVN_DEPRECATED 3350svn_error_t * 3351svn_wc_get_ancestry(char **url, 3352 svn_revnum_t *rev, 3353 const char *path, 3354 svn_wc_adm_access_t *adm_access, 3355 apr_pool_t *pool); 3356 3357 3358/** A callback vtable invoked by the generic entry-walker function. 3359 * @since New in 1.5. 3360 */ 3361typedef struct svn_wc_entry_callbacks2_t 3362{ 3363 /** An @a entry was found at @a path. */ 3364 svn_error_t *(*found_entry)(const char *path, 3365 const svn_wc_entry_t *entry, 3366 void *walk_baton, 3367 apr_pool_t *pool); 3368 3369 /** Handle the error @a err encountered while processing @a path. 3370 * Wrap or squelch @a err as desired, and return an #svn_error_t 3371 * *, or #SVN_NO_ERROR. 3372 */ 3373 svn_error_t *(*handle_error)(const char *path, 3374 svn_error_t *err, 3375 void *walk_baton, 3376 apr_pool_t *pool); 3377 3378} svn_wc_entry_callbacks2_t; 3379 3380/** @deprecated Provided for backward compatibility with the 1.4 API. */ 3381typedef struct svn_wc_entry_callbacks_t 3382{ 3383 /** An @a entry was found at @a path. */ 3384 svn_error_t *(*found_entry)(const char *path, 3385 const svn_wc_entry_t *entry, 3386 void *walk_baton, 3387 apr_pool_t *pool); 3388 3389} svn_wc_entry_callbacks_t; 3390 3391/** 3392 * A generic entry-walker. 3393 * 3394 * Do a potentially recursive depth-first entry-walk beginning on 3395 * @a path, which can be a file or dir. Call callbacks in 3396 * @a walk_callbacks, passing @a walk_baton to each. Use @a pool for 3397 * looping, recursion, and to allocate all entries returned. 3398 * @a adm_access must be an access baton for @a path. The pool 3399 * passed to @a walk_callbacks is a temporary subpool of @a pool. 3400 * 3401 * If @a depth is #svn_depth_empty, invoke the callbacks on @a path 3402 * and return without recursing further. If #svn_depth_files, do 3403 * the same and invoke the callbacks on file children (if any) of 3404 * @a path, then return. If #svn_depth_immediates, do the preceding 3405 * but also invoke callbacks on immediate subdirectories, then return. 3406 * If #svn_depth_infinity, recurse fully starting from @a path. 3407 * 3408 * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine 3409 * if the client has canceled the operation. 3410 * 3411 * Like our other entries interfaces, entries that are in a 'excluded', 3412 * 'deleted' or 'absent' state (and not scheduled for re-addition) are not 3413 * discovered, unless @a show_hidden is TRUE. Excluded entries are those with 3414 * their depth set to #svn_depth_exclude. 3415 * 3416 * When a new directory is entered, #SVN_WC_ENTRY_THIS_DIR will always 3417 * be returned first. 3418 * 3419 * @note Callers should be aware that each directory will be 3420 * returned *twice*: first as an entry within its parent, and 3421 * subsequently as the '.' entry within itself. The two calls can be 3422 * distinguished by looking for #SVN_WC_ENTRY_THIS_DIR in the 'name' 3423 * field of the entry. 3424 * 3425 * @since New in 1.5. 3426 * @deprecated Provided for backward compatibility with the 1.6 API. 3427 */ 3428SVN_DEPRECATED 3429svn_error_t * 3430svn_wc_walk_entries3(const char *path, 3431 svn_wc_adm_access_t *adm_access, 3432 const svn_wc_entry_callbacks2_t *walk_callbacks, 3433 void *walk_baton, 3434 svn_depth_t depth, 3435 svn_boolean_t show_hidden, 3436 svn_cancel_func_t cancel_func, 3437 void *cancel_baton, 3438 apr_pool_t *pool); 3439 3440/** 3441 * Similar to svn_wc_walk_entries3(), but without cancellation support 3442 * or error handling from @a walk_callbacks, and with @a depth always 3443 * set to #svn_depth_infinity. 3444 * 3445 * @since New in 1.2. 3446 * @deprecated Provided for backward compatibility with the 1.4 API. 3447 */ 3448SVN_DEPRECATED 3449svn_error_t * 3450svn_wc_walk_entries2(const char *path, 3451 svn_wc_adm_access_t *adm_access, 3452 const svn_wc_entry_callbacks_t *walk_callbacks, 3453 void *walk_baton, 3454 svn_boolean_t show_hidden, 3455 svn_cancel_func_t cancel_func, 3456 void *cancel_baton, 3457 apr_pool_t *pool); 3458 3459/** 3460 * Similar to svn_wc_walk_entries2(), but without cancellation support. 3461 * 3462 * @deprecated Provided for backward compatibility with the 1.1 API. 3463 */ 3464SVN_DEPRECATED 3465svn_error_t * 3466svn_wc_walk_entries(const char *path, 3467 svn_wc_adm_access_t *adm_access, 3468 const svn_wc_entry_callbacks_t *walk_callbacks, 3469 void *walk_baton, 3470 svn_boolean_t show_hidden, 3471 apr_pool_t *pool); 3472 3473 3474/** Mark missing @a path as 'deleted' in its @a parent's list of 3475 * entries. @a path should be a directory that is both deleted (via 3476 * svn_wc_delete4) and removed (via a system call). This function 3477 * should only be called during post-commit processing following a 3478 * successful commit editor drive. 3479 * 3480 * Return #SVN_ERR_WC_PATH_FOUND if @a path isn't actually missing. 3481 * 3482 * @deprecated Provided for backward compatibility with the 1.6 API. 3483 */ 3484SVN_DEPRECATED 3485svn_error_t * 3486svn_wc_mark_missing_deleted(const char *path, 3487 svn_wc_adm_access_t *parent, 3488 apr_pool_t *pool); 3489 3490 3491/** Ensure that an administrative area exists for @a local_abspath, so 3492 * that @a local_abspath is a working copy subdir based on @a url at @a 3493 * revision, with depth @a depth, and with repository UUID @a repos_uuid 3494 * and repository root URL @a repos_root_url. 3495 * 3496 * @a depth must be a definite depth, it cannot be #svn_depth_unknown. 3497 * @a repos_uuid and @a repos_root_url MUST NOT be @c NULL, and 3498 * @a repos_root_url must be a prefix of @a url. 3499 * 3500 * If the administrative area does not exist, then create it and 3501 * initialize it to an unlocked state. 3502 * 3503 * If the administrative area already exists then the given @a url 3504 * must match the URL in the administrative area and the given 3505 * @a revision must match the BASE of the working copy dir unless 3506 * the admin directory is scheduled for deletion or the 3507 * #SVN_ERR_WC_OBSTRUCTED_UPDATE error will be returned. 3508 * 3509 * Do not ensure existence of @a local_abspath itself; if @a local_abspath 3510 * does not exist, return error. 3511 * 3512 * Use @a scratch_pool for temporary allocations. 3513 * 3514 * @since New in 1.7. 3515 */ 3516svn_error_t * 3517svn_wc_ensure_adm4(svn_wc_context_t *wc_ctx, 3518 const char *local_abspath, 3519 const char *url, 3520 const char *repos_root_url, 3521 const char *repos_uuid, 3522 svn_revnum_t revision, 3523 svn_depth_t depth, 3524 apr_pool_t *scratch_pool); 3525 3526/** 3527 * Similar to svn_wc_ensure_adm4(), but without the wc context parameter. 3528 * 3529 * @note the @a uuid and @a repos parameters were documented as allowing 3530 * @c NULL to be passed. Beginning with 1.7, this will return an error, 3531 * contrary to prior documented behavior: see 'notes/api-errata/1.7/wc005.txt'. 3532 * 3533 * @since New in 1.5. 3534 * @deprecated Provided for backwards compatibility with the 1.6 API. 3535 */ 3536SVN_DEPRECATED 3537svn_error_t * 3538svn_wc_ensure_adm3(const char *path, 3539 const char *uuid, 3540 const char *url, 3541 const char *repos, 3542 svn_revnum_t revision, 3543 svn_depth_t depth, 3544 apr_pool_t *pool); 3545 3546 3547/** 3548 * Similar to svn_wc_ensure_adm3(), but with @a depth set to 3549 * #svn_depth_infinity. 3550 * 3551 * See the note on svn_wc_ensure_adm3() regarding the @a repos and @a uuid 3552 * parameters. 3553 * 3554 * @since New in 1.3. 3555 * @deprecated Provided for backwards compatibility with the 1.4 API. 3556 */ 3557SVN_DEPRECATED 3558svn_error_t * 3559svn_wc_ensure_adm2(const char *path, 3560 const char *uuid, 3561 const char *url, 3562 const char *repos, 3563 svn_revnum_t revision, 3564 apr_pool_t *pool); 3565 3566 3567/** 3568 * Similar to svn_wc_ensure_adm2(), but with @a repos set to @c NULL. 3569 * 3570 * @note as of 1.7, this function always returns #SVN_ERR_BAD_URL since 3571 * the @a repos parameter may not be @c NULL. 3572 * 3573 * @deprecated Provided for backwards compatibility with the 1.2 API. 3574 */ 3575SVN_DEPRECATED 3576svn_error_t * 3577svn_wc_ensure_adm(const char *path, 3578 const char *uuid, 3579 const char *url, 3580 svn_revnum_t revision, 3581 apr_pool_t *pool); 3582 3583 3584/** Set the repository root URL of @a path to @a repos, if possible. 3585 * 3586 * Before Subversion 1.7 there could be working copy directories that 3587 * didn't have a stored repository root in some specific circumstances. 3588 * This function allowed setting this root later. 3589 * 3590 * Since Subversion 1.7 this function just returns #SVN_NO_ERROR. 3591 * 3592 * @since New in 1.3. 3593 * @deprecated Provided for backwards compatibility with the 1.6 API. 3594 */ 3595SVN_DEPRECATED 3596svn_error_t * 3597svn_wc_maybe_set_repos_root(svn_wc_adm_access_t *adm_access, 3598 const char *path, 3599 const char *repos, 3600 apr_pool_t *pool); 3601 3602 3603/** 3604 * @defgroup svn_wc_status Working copy status. 3605 * @{ 3606 * 3607 * We have three functions for getting working copy status: one function 3608 * for getting the status of exactly one thing, another for 3609 * getting the statuses of (potentially) multiple things and a third for 3610 * getting the working copy out-of-dateness with respect to the repository. 3611 * 3612 * Why do we have two different functions for getting working copy status? 3613 * The concept of depth, as explained in the documentation for 3614 * svn_depth_t, may be useful in understanding this. Suppose we're 3615 * getting the status of directory D: 3616 * 3617 * To offer all three levels, we could have one unified function, 3618 * taking a `depth' parameter. Unfortunately, because this function 3619 * would have to handle multiple return values as well as the single 3620 * return value case, getting the status of just one entity would 3621 * become cumbersome: you'd have to roll through a hash to find one 3622 * lone status. 3623 * 3624 * So we have svn_wc_status3() for depth-empty (just D itself), and 3625 * svn_wc_walk_status() for depth-immediates and depth-infinity, 3626 * since the latter two involve multiple return values. And for 3627 * out-of-dateness information we have svn_wc_get_status_editor5(). 3628 */ 3629 3630/** The type of status for the working copy. */ 3631enum svn_wc_status_kind 3632{ 3633 /** does not exist */ 3634 svn_wc_status_none = 1, 3635 3636 /** is not a versioned thing in this wc */ 3637 svn_wc_status_unversioned, 3638 3639 /** exists, but uninteresting */ 3640 svn_wc_status_normal, 3641 3642 /** is scheduled for addition */ 3643 svn_wc_status_added, 3644 3645 /** under v.c., but is missing */ 3646 svn_wc_status_missing, 3647 3648 /** scheduled for deletion */ 3649 svn_wc_status_deleted, 3650 3651 /** was deleted and then re-added */ 3652 svn_wc_status_replaced, 3653 3654 /** text or props have been modified */ 3655 svn_wc_status_modified, 3656 3657 /** local mods received repos mods (### unused) */ 3658 svn_wc_status_merged, 3659 3660 /** local mods received conflicting repos mods */ 3661 svn_wc_status_conflicted, 3662 3663 /** is unversioned but configured to be ignored */ 3664 svn_wc_status_ignored, 3665 3666 /** an unversioned resource is in the way of the versioned resource */ 3667 svn_wc_status_obstructed, 3668 3669 /** an unversioned directory path populated by an svn:externals 3670 property; this status is not used for file externals */ 3671 svn_wc_status_external, 3672 3673 /** a directory doesn't contain a complete entries list */ 3674 svn_wc_status_incomplete 3675}; 3676 3677/** 3678 * Structure for holding the "status" of a working copy item. 3679 * 3680 * @note Fields may be added to the end of this structure in future 3681 * versions. Therefore, to preserve binary compatibility, users 3682 * should not directly allocate structures of this type. 3683 * 3684 * @since New in 1.7. 3685 */ 3686typedef struct svn_wc_status3_t 3687{ 3688 /** The kind of node as recorded in the working copy */ 3689 svn_node_kind_t kind; 3690 3691 /** The depth of the node as recorded in the working copy 3692 * (#svn_depth_unknown for files or when no depth is set) */ 3693 svn_depth_t depth; 3694 3695 /** The actual size of the working file on disk, or SVN_INVALID_FILESIZE 3696 * if unknown (or if the item isn't a file at all). */ 3697 svn_filesize_t filesize; 3698 3699 /** If the path is under version control, versioned is TRUE, otherwise 3700 * FALSE. */ 3701 svn_boolean_t versioned; 3702 3703 /** Set to TRUE if the item is the victim of a conflict. */ 3704 svn_boolean_t conflicted; 3705 3706 /** The status of the node itself. In order of precedence: Obstructions, 3707 * structural changes, text changes. */ 3708 enum svn_wc_status_kind node_status; 3709 3710 /** The status of the entry's text. */ 3711 enum svn_wc_status_kind text_status; 3712 3713 /** The status of the entry's properties. */ 3714 enum svn_wc_status_kind prop_status; 3715 3716 /** a file or directory can be 'copied' if it's scheduled for 3717 * addition-with-history (or part of a subtree that is scheduled as such.). 3718 */ 3719 svn_boolean_t copied; 3720 3721 /** Base revision. */ 3722 svn_revnum_t revision; 3723 3724 /** Last revision this was changed */ 3725 svn_revnum_t changed_rev; 3726 3727 /** Date of last commit. */ 3728 apr_time_t changed_date; 3729 3730 /** Last commit author of this item */ 3731 const char *changed_author; 3732 3733 /** The URL of the repository */ 3734 const char *repos_root_url; 3735 3736 /** The UUID of the repository */ 3737 const char *repos_uuid; 3738 3739 /** The in-repository path relative to the repository root. */ 3740 const char *repos_relpath; 3741 3742 /** a file or directory can be 'switched' if the switch command has been 3743 * used. If this is TRUE, then file_external will be FALSE. 3744 */ 3745 svn_boolean_t switched; 3746 3747 /** This directory has a working copy lock */ 3748 svn_boolean_t locked; 3749 3750 /** The repository file lock. (Values of path, token, owner, comment 3751 * and are available if a lock is present) */ 3752 const svn_lock_t *lock; 3753 3754 /** Which changelist this item is part of, or NULL if not part of any. */ 3755 const char *changelist; 3756 3757 /** 3758 * @defgroup svn_wc_status_ood WC out-of-date info from the repository 3759 * @{ 3760 * 3761 * When the working copy item is out-of-date compared to the 3762 * repository, the following fields represent the state of the 3763 * youngest revision of the item in the repository. If the working 3764 * copy is not out of date, the fields are initialized as described 3765 * below. 3766 */ 3767 3768 /** Set to the node kind of the youngest commit, or #svn_node_none 3769 * if not out of date. */ 3770 svn_node_kind_t ood_kind; 3771 3772 /** The status of the node, based on the text status if the node has no 3773 * restructuring changes */ 3774 enum svn_wc_status_kind repos_node_status; 3775 3776 /** The entry's text status in the repository. */ 3777 enum svn_wc_status_kind repos_text_status; 3778 3779 /** The entry's property status in the repository. */ 3780 enum svn_wc_status_kind repos_prop_status; 3781 3782 /** The entry's lock in the repository, if any. */ 3783 const svn_lock_t *repos_lock; 3784 3785 /** Set to the youngest committed revision, or #SVN_INVALID_REVNUM 3786 * if not out of date. */ 3787 svn_revnum_t ood_changed_rev; 3788 3789 /** Set to the most recent commit date, or @c 0 if not out of date. */ 3790 apr_time_t ood_changed_date; 3791 3792 /** Set to the user name of the youngest commit, or @c NULL if not 3793 * out of date or non-existent. Because a non-existent @c 3794 * svn:author property has the same behavior as an out-of-date 3795 * working copy, examine @c ood_last_cmt_rev to determine whether 3796 * the working copy is out of date. */ 3797 const char *ood_changed_author; 3798 3799 /** @} */ 3800 3801 /** Set to the local absolute path that this node was moved from, if this 3802 * file or directory has been moved here locally and is the root of that 3803 * move. Otherwise set to NULL. 3804 * 3805 * This will be NULL for moved-here nodes that are just part of a subtree 3806 * that was moved along (and are not themselves a root of a different move 3807 * operation). 3808 * 3809 * @since New in 1.8. */ 3810 const char *moved_from_abspath; 3811 3812 /** Set to the local absolute path that this node was moved to, if this file 3813 * or directory has been moved away locally and corresponds to the root 3814 * of the destination side of the move. Otherwise set to NULL. 3815 * 3816 * Note: Saying just "root" here could be misleading. For example: 3817 * svn mv A AA; 3818 * svn mv AA/B BB; 3819 * creates a situation where A/B is moved-to BB, but one could argue that 3820 * the move source's root actually was AA/B. Note that, as far as the 3821 * working copy is concerned, above case is exactly identical to: 3822 * svn mv A/B BB; 3823 * svn mv A AA; 3824 * In both situations, @a moved_to_abspath would be set for nodes A (moved 3825 * to AA) and A/B (moved to BB), only. 3826 * 3827 * This will be NULL for moved-away nodes that were just part of a subtree 3828 * that was moved along (and are not themselves a root of a different move 3829 * operation). 3830 * 3831 * @since New in 1.8. */ 3832 const char *moved_to_abspath; 3833 3834 /** @c TRUE iff the item is a file brought in by an svn:externals definition. 3835 * @since New in 1.8. */ 3836 svn_boolean_t file_external; 3837 3838 3839 /** The actual kind of the node in the working copy. May differ from 3840 * @a kind on obstructions, deletes, etc. #svn_node_unknown if unavailable. 3841 * 3842 * @since New in 1.9 */ 3843 svn_node_kind_t actual_kind; 3844 3845 /* NOTE! Please update svn_wc_dup_status3() when adding new fields here. */ 3846} svn_wc_status3_t; 3847 3848/** 3849 * ### All diffs are not yet known. 3850 * Same as svn_wc_status3_t, but without the #svn_boolean_t 'versioned' 3851 * field. Instead an item that is not versioned has the 'entry' field set to 3852 * @c NULL. 3853 * 3854 * @since New in 1.2. 3855 * @deprecated Provided for backward compatibility with the 1.6 API. 3856 */ 3857typedef struct svn_wc_status2_t 3858{ 3859 /** Can be @c NULL if not under version control. */ 3860 const svn_wc_entry_t *entry; 3861 3862 /** The status of the entry itself, including its text if it is a file. */ 3863 enum svn_wc_status_kind text_status; 3864 3865 /** The status of the entry's properties. */ 3866 enum svn_wc_status_kind prop_status; 3867 3868 /** a directory can be 'locked' if a working copy update was interrupted. */ 3869 svn_boolean_t locked; 3870 3871 /** a file or directory can be 'copied' if it's scheduled for 3872 * addition-with-history (or part of a subtree that is scheduled as such.). 3873 */ 3874 svn_boolean_t copied; 3875 3876 /** a file or directory can be 'switched' if the switch command has been 3877 * used. If this is TRUE, then file_external will be FALSE. 3878 */ 3879 svn_boolean_t switched; 3880 3881 /** The entry's text status in the repository. */ 3882 enum svn_wc_status_kind repos_text_status; 3883 3884 /** The entry's property status in the repository. */ 3885 enum svn_wc_status_kind repos_prop_status; 3886 3887 /** The entry's lock in the repository, if any. */ 3888 svn_lock_t *repos_lock; 3889 3890 /** Set to the URI (actual or expected) of the item. 3891 * @since New in 1.3 3892 */ 3893 const char *url; 3894 3895 /** 3896 * @defgroup svn_wc_status_ood WC out-of-date info from the repository 3897 * @{ 3898 * 3899 * When the working copy item is out-of-date compared to the 3900 * repository, the following fields represent the state of the 3901 * youngest revision of the item in the repository. If the working 3902 * copy is not out of date, the fields are initialized as described 3903 * below. 3904 */ 3905 3906 /** Set to the youngest committed revision, or #SVN_INVALID_REVNUM 3907 * if not out of date. 3908 * @since New in 1.3 3909 */ 3910 svn_revnum_t ood_last_cmt_rev; 3911 3912 /** Set to the most recent commit date, or @c 0 if not out of date. 3913 * @since New in 1.3 3914 */ 3915 apr_time_t ood_last_cmt_date; 3916 3917 /** Set to the node kind of the youngest commit, or #svn_node_none 3918 * if not out of date. 3919 * @since New in 1.3 3920 */ 3921 svn_node_kind_t ood_kind; 3922 3923 /** Set to the user name of the youngest commit, or @c NULL if not 3924 * out of date or non-existent. Because a non-existent @c 3925 * svn:author property has the same behavior as an out-of-date 3926 * working copy, examine @c ood_last_cmt_rev to determine whether 3927 * the working copy is out of date. 3928 * @since New in 1.3 3929 */ 3930 const char *ood_last_cmt_author; 3931 3932 /** @} */ 3933 3934 /** Non-NULL if the entry is the victim of a tree conflict. 3935 * @since New in 1.6 3936 */ 3937 svn_wc_conflict_description_t *tree_conflict; 3938 3939 /** If the item is a file that was added to the working copy with an 3940 * svn:externals; if file_external is TRUE, then switched is always 3941 * FALSE. 3942 * @since New in 1.6 3943 */ 3944 svn_boolean_t file_external; 3945 3946 /** The actual status of the text compared to the pristine base of the 3947 * file. This value isn't masked by other working copy statuses. 3948 * @c pristine_text_status is #svn_wc_status_none if this value was 3949 * not calculated during the status walk. 3950 * @since New in 1.6 3951 */ 3952 enum svn_wc_status_kind pristine_text_status; 3953 3954 /** The actual status of the properties compared to the pristine base of 3955 * the node. This value isn't masked by other working copy statuses. 3956 * @c pristine_prop_status is #svn_wc_status_none if this value was 3957 * not calculated during the status walk. 3958 * @since New in 1.6 3959 */ 3960 enum svn_wc_status_kind pristine_prop_status; 3961 3962} svn_wc_status2_t; 3963 3964 3965 3966/** 3967 * Same as #svn_wc_status2_t, but without the #svn_lock_t 'repos_lock', const char 'url', #svn_revnum_t 'ood_last_cmt_rev', apr_time_t 'ood_last_cmt_date', #svn_node_kind_t 'ood_kind', const char 'ood_last_cmt_author', #svn_wc_conflict_description_t 'tree_conflict', #svn_boolean_t 'file_external', #svn_wc_status_kind 'pristine_text_status', and #svn_wc_status_kind 'pristine_prop_status' fields. 3968 * 3969 * @deprecated Provided for backward compatibility with the 1.1 API. 3970 */ 3971typedef struct svn_wc_status_t 3972{ 3973 /** Can be @c NULL if not under version control. */ 3974 const svn_wc_entry_t *entry; 3975 3976 /** The status of the entries text. */ 3977 enum svn_wc_status_kind text_status; 3978 3979 /** The status of the entries properties. */ 3980 enum svn_wc_status_kind prop_status; 3981 3982 /** a directory can be 'locked' if a working copy update was interrupted. */ 3983 svn_boolean_t locked; 3984 3985 /** a file or directory can be 'copied' if it's scheduled for 3986 * addition-with-history (or part of a subtree that is scheduled as such.). 3987 */ 3988 svn_boolean_t copied; 3989 3990 /** a file or directory can be 'switched' if the switch command has been 3991 * used. 3992 */ 3993 svn_boolean_t switched; 3994 3995 /** The entry's text status in the repository. */ 3996 enum svn_wc_status_kind repos_text_status; 3997 3998 /** The entry's property status in the repository. */ 3999 enum svn_wc_status_kind repos_prop_status; 4000 4001} svn_wc_status_t; 4002 4003 4004/** 4005 * Return a deep copy of the @a orig_stat status structure, allocated 4006 * in @a pool. 4007 * 4008 * @since New in 1.7. 4009 */ 4010svn_wc_status3_t * 4011svn_wc_dup_status3(const svn_wc_status3_t *orig_stat, 4012 apr_pool_t *pool); 4013 4014/** 4015 * Same as svn_wc_dup_status3(), but for older svn_wc_status_t structures. 4016 * 4017 * @since New in 1.2 4018 * @deprecated Provided for backward compatibility with the 1.6 API. 4019 */ 4020SVN_DEPRECATED 4021svn_wc_status2_t * 4022svn_wc_dup_status2(const svn_wc_status2_t *orig_stat, 4023 apr_pool_t *pool); 4024 4025 4026/** 4027 * Same as svn_wc_dup_status2(), but for older svn_wc_status_t structures. 4028 * 4029 * @deprecated Provided for backward compatibility with the 1.1 API. 4030 */ 4031SVN_DEPRECATED 4032svn_wc_status_t * 4033svn_wc_dup_status(const svn_wc_status_t *orig_stat, 4034 apr_pool_t *pool); 4035 4036 4037/** 4038 * Fill @a *status for @a local_abspath, allocating in @a result_pool. 4039 * Use @a scratch_pool for temporary allocations. 4040 * 4041 * Here are some things to note about the returned structure. A quick 4042 * examination of the @c status->text_status after a successful return of 4043 * this function can reveal the following things: 4044 * 4045 * - #svn_wc_status_none : @a local_abspath is not versioned, and is 4046 * not present on disk 4047 * 4048 * - #svn_wc_status_missing : @a local_abspath is versioned, but is 4049 * missing from the working copy. 4050 * 4051 * - #svn_wc_status_unversioned : @a local_abspath is not versioned, 4052 * but is present on disk and not being 4053 * ignored (see above). 4054 * 4055 * The other available results for the @c text_status field are more 4056 * straightforward in their meanings. See the comments on the 4057 * #svn_wc_status_kind structure for some hints. 4058 * 4059 * @since New in 1.7. 4060 */ 4061svn_error_t * 4062svn_wc_status3(svn_wc_status3_t **status, 4063 svn_wc_context_t *wc_ctx, 4064 const char *local_abspath, 4065 apr_pool_t *result_pool, 4066 apr_pool_t *scratch_pool); 4067 4068/** Similar to svn_wc_status3(), but with a adm_access baton and absolute 4069 * path. 4070 * 4071 * @since New in 1.2. 4072 * @deprecated Provided for backward compatibility with the 1.6 API. 4073 */ 4074SVN_DEPRECATED 4075svn_error_t * 4076svn_wc_status2(svn_wc_status2_t **status, 4077 const char *path, 4078 svn_wc_adm_access_t *adm_access, 4079 apr_pool_t *pool); 4080 4081 4082/** 4083 * Same as svn_wc_status2(), but for older svn_wc_status_t structures. 4084 * 4085 * @deprecated Provided for backward compatibility with the 1.1 API. 4086 */ 4087SVN_DEPRECATED 4088svn_error_t * 4089svn_wc_status(svn_wc_status_t **status, 4090 const char *path, 4091 svn_wc_adm_access_t *adm_access, 4092 apr_pool_t *pool); 4093 4094 4095 4096 4097/** 4098 * A callback for reporting a @a status about @a local_abspath. 4099 * 4100 * @a baton is a closure object; it should be provided by the 4101 * implementation, and passed by the caller. 4102 * 4103 * @a scratch_pool will be cleared between invocations to the callback. 4104 * 4105 * @since New in 1.7. 4106 */ 4107typedef svn_error_t *(*svn_wc_status_func4_t)(void *baton, 4108 const char *local_abspath, 4109 const svn_wc_status3_t *status, 4110 apr_pool_t *scratch_pool); 4111 4112/** 4113 * Same as svn_wc_status_func4_t, but with a non-const status and a relative 4114 * path. 4115 * 4116 * @since New in 1.6. 4117 * @deprecated Provided for backward compatibility with the 1.6 API. 4118 */ 4119typedef svn_error_t *(*svn_wc_status_func3_t)(void *baton, 4120 const char *path, 4121 svn_wc_status2_t *status, 4122 apr_pool_t *pool); 4123 4124/** 4125 * Same as svn_wc_status_func3_t, but without a provided pool or 4126 * the ability to propagate errors. 4127 * 4128 * @since New in 1.2. 4129 * @deprecated Provided for backward compatibility with the 1.5 API. 4130 */ 4131typedef void (*svn_wc_status_func2_t)(void *baton, 4132 const char *path, 4133 svn_wc_status2_t *status); 4134 4135/** 4136 * Same as svn_wc_status_func2_t, but for older svn_wc_status_t structures. 4137 * 4138 * @deprecated Provided for backward compatibility with the 1.1 API. 4139 */ 4140typedef void (*svn_wc_status_func_t)(void *baton, 4141 const char *path, 4142 svn_wc_status_t *status); 4143 4144/** 4145 * Walk the working copy status of @a local_abspath using @a wc_ctx, by 4146 * creating #svn_wc_status3_t structures and sending these through 4147 * @a status_func / @a status_baton. 4148 * 4149 * * Assuming the target is a directory, then: 4150 * 4151 * - If @a get_all is FALSE, then only locally-modified entries will be 4152 * returned. If TRUE, then all entries will be returned. 4153 * 4154 * - If @a ignore_text_mods is TRUE, then the walk will not check for 4155 * modified files. Any #svn_wc_status3_t structures returned for files 4156 * will always have a text_status field set to svn_wc_status_normal. 4157 * If @a ignore_text_mods is FALSE, the walk checks for text changes 4158 * and returns #svn_wc_status3_t structures describing any changes. 4159 * 4160 * - If @a depth is #svn_depth_empty, a status structure will 4161 * be returned for the target only; if #svn_depth_files, for the 4162 * target and its immediate file children; if 4163 * #svn_depth_immediates, for the target and its immediate 4164 * children; if #svn_depth_infinity, for the target and 4165 * everything underneath it, fully recursively. 4166 * 4167 * If @a depth is #svn_depth_unknown, take depths from the 4168 * working copy and behave as above in each directory's case. 4169 * 4170 * If the given @a depth is incompatible with the depth found in a 4171 * working copy directory, the found depth always governs. 4172 * 4173 * If @a no_ignore is set, statuses that would typically be ignored 4174 * will instead be reported. 4175 * 4176 * @a ignore_patterns is an array of file patterns matching 4177 * unversioned files to ignore for the purposes of status reporting, 4178 * or @c NULL if the default set of ignorable file patterns should be used. 4179 * Patterns from #SVN_PROP_IGNORE (and, as of 1.8, 4180 * #SVN_PROP_INHERITABLE_IGNORES) properties are always used, even if not 4181 * specified in @a ignore_patterns. 4182 * 4183 * If @a cancel_func is non-NULL, call it with @a cancel_baton while walking 4184 * to determine if the client has canceled the operation. 4185 * 4186 * This function uses @a scratch_pool for temporary allocations. 4187 * 4188 * @since New in 1.7. 4189 */ 4190svn_error_t * 4191svn_wc_walk_status(svn_wc_context_t *wc_ctx, 4192 const char *local_abspath, 4193 svn_depth_t depth, 4194 svn_boolean_t get_all, 4195 svn_boolean_t no_ignore, 4196 svn_boolean_t ignore_text_mods, 4197 const apr_array_header_t *ignore_patterns, 4198 svn_wc_status_func4_t status_func, 4199 void *status_baton, 4200 svn_cancel_func_t cancel_func, 4201 void *cancel_baton, 4202 apr_pool_t *scratch_pool); 4203 4204/** 4205 * DEPRECATED -- please use APIs from svn_client.h 4206 * 4207 * --- 4208 * 4209 * Set @a *editor and @a *edit_baton to an editor that generates 4210 * #svn_wc_status3_t structures and sends them through @a status_func / 4211 * @a status_baton. @a anchor_abspath is a working copy directory 4212 * directory which will be used as the root of our editor. If @a 4213 * target_basename is not "", it represents a node in the @a anchor_abspath 4214 * which is the subject of the editor drive (otherwise, the @a 4215 * anchor_abspath is the subject). 4216 * 4217 * If @a set_locks_baton is non-@c NULL, it will be set to a baton that can 4218 * be used in a call to the svn_wc_status_set_repos_locks() function. 4219 * 4220 * Callers drive this editor to describe working copy out-of-dateness 4221 * with respect to the repository. If this information is not 4222 * available or not desired, callers should simply call the 4223 * close_edit() function of the @a editor vtable. 4224 * 4225 * If the editor driver calls @a editor's set_target_revision() vtable 4226 * function, then when the edit drive is completed, @a *edit_revision 4227 * will contain the revision delivered via that interface. 4228 * 4229 * Assuming the target is a directory, then: 4230 * 4231 * - If @a get_all is FALSE, then only locally-modified entries will be 4232 * returned. If TRUE, then all entries will be returned. 4233 * 4234 * - If @a depth is #svn_depth_empty, a status structure will 4235 * be returned for the target only; if #svn_depth_files, for the 4236 * target and its immediate file children; if 4237 * #svn_depth_immediates, for the target and its immediate 4238 * children; if #svn_depth_infinity, for the target and 4239 * everything underneath it, fully recursively. 4240 * 4241 * If @a depth is #svn_depth_unknown, take depths from the 4242 * working copy and behave as above in each directory's case. 4243 * 4244 * If the given @a depth is incompatible with the depth found in a 4245 * working copy directory, the found depth always governs. 4246 * 4247 * If @a no_ignore is set, statuses that would typically be ignored 4248 * will instead be reported. 4249 * 4250 * @a ignore_patterns is an array of file patterns matching 4251 * unversioned files to ignore for the purposes of status reporting, 4252 * or @c NULL if the default set of ignorable file patterns should be used. 4253 * 4254 * If @a cancel_func is non-NULL, call it with @a cancel_baton while building 4255 * the @a statushash to determine if the client has canceled the operation. 4256 * 4257 * If @a depth_as_sticky is set handle @a depth like when depth_is_sticky is 4258 * passed for updating. This will show excluded nodes show up as added in the 4259 * repository. 4260 * 4261 * If @a server_performs_filtering is TRUE, assume that the server handles 4262 * the ambient depth filtering, so this doesn't have to be handled in the 4263 * editor. 4264 * 4265 * Allocate the editor itself in @a result_pool, and use @a scratch_pool 4266 * for temporary allocations. The editor will do its temporary allocations 4267 * in a subpool of @a result_pool. 4268 * 4269 * @since New in 1.7. 4270 * @deprecated Provided for backward compatibility with the 1.7 API. 4271 */ 4272SVN_DEPRECATED 4273svn_error_t * 4274svn_wc_get_status_editor5(const svn_delta_editor_t **editor, 4275 void **edit_baton, 4276 void **set_locks_baton, 4277 svn_revnum_t *edit_revision, 4278 svn_wc_context_t *wc_ctx, 4279 const char *anchor_abspath, 4280 const char *target_basename, 4281 svn_depth_t depth, 4282 svn_boolean_t get_all, 4283 svn_boolean_t no_ignore, 4284 svn_boolean_t depth_as_sticky, 4285 svn_boolean_t server_performs_filtering, 4286 const apr_array_header_t *ignore_patterns, 4287 svn_wc_status_func4_t status_func, 4288 void *status_baton, 4289 svn_cancel_func_t cancel_func, 4290 void *cancel_baton, 4291 apr_pool_t *result_pool, 4292 apr_pool_t *scratch_pool); 4293 4294/** 4295 * Same as svn_wc_get_status_editor5, but using #svn_wc_status_func3_t 4296 * instead of #svn_wc_status_func4_t. And @a server_performs_filtering 4297 * always set to #TRUE. 4298 * 4299 * This also uses a single pool parameter, stating that all temporary 4300 * allocations are performed in manually constructed/destroyed subpool. 4301 * 4302 * @since New in 1.6. 4303 * @deprecated Provided for backward compatibility with the 1.6 API. 4304 */ 4305SVN_DEPRECATED 4306svn_error_t * 4307svn_wc_get_status_editor4(const svn_delta_editor_t **editor, 4308 void **edit_baton, 4309 void **set_locks_baton, 4310 svn_revnum_t *edit_revision, 4311 svn_wc_adm_access_t *anchor, 4312 const char *target, 4313 svn_depth_t depth, 4314 svn_boolean_t get_all, 4315 svn_boolean_t no_ignore, 4316 const apr_array_header_t *ignore_patterns, 4317 svn_wc_status_func3_t status_func, 4318 void *status_baton, 4319 svn_cancel_func_t cancel_func, 4320 void *cancel_baton, 4321 svn_wc_traversal_info_t *traversal_info, 4322 apr_pool_t *pool); 4323 4324/** 4325 * Same as svn_wc_get_status_editor4(), but using #svn_wc_status_func2_t 4326 * instead of #svn_wc_status_func3_t. 4327 * 4328 * @since New in 1.5. 4329 * @deprecated Provided for backward compatibility with the 1.5 API. 4330 */ 4331SVN_DEPRECATED 4332svn_error_t * 4333svn_wc_get_status_editor3(const svn_delta_editor_t **editor, 4334 void **edit_baton, 4335 void **set_locks_baton, 4336 svn_revnum_t *edit_revision, 4337 svn_wc_adm_access_t *anchor, 4338 const char *target, 4339 svn_depth_t depth, 4340 svn_boolean_t get_all, 4341 svn_boolean_t no_ignore, 4342 const apr_array_header_t *ignore_patterns, 4343 svn_wc_status_func2_t status_func, 4344 void *status_baton, 4345 svn_cancel_func_t cancel_func, 4346 void *cancel_baton, 4347 svn_wc_traversal_info_t *traversal_info, 4348 apr_pool_t *pool); 4349 4350/** 4351 * Like svn_wc_get_status_editor3(), but with @a ignore_patterns 4352 * provided from the corresponding value in @a config, and @a recurse 4353 * instead of @a depth. If @a recurse is TRUE, behave as if for 4354 * #svn_depth_infinity; else if @a recurse is FALSE, behave as if for 4355 * #svn_depth_immediates. 4356 * 4357 * @since New in 1.2. 4358 * @deprecated Provided for backward compatibility with the 1.4 API. 4359 */ 4360SVN_DEPRECATED 4361svn_error_t * 4362svn_wc_get_status_editor2(const svn_delta_editor_t **editor, 4363 void **edit_baton, 4364 void **set_locks_baton, 4365 svn_revnum_t *edit_revision, 4366 svn_wc_adm_access_t *anchor, 4367 const char *target, 4368 apr_hash_t *config, 4369 svn_boolean_t recurse, 4370 svn_boolean_t get_all, 4371 svn_boolean_t no_ignore, 4372 svn_wc_status_func2_t status_func, 4373 void *status_baton, 4374 svn_cancel_func_t cancel_func, 4375 void *cancel_baton, 4376 svn_wc_traversal_info_t *traversal_info, 4377 apr_pool_t *pool); 4378 4379/** 4380 * Same as svn_wc_get_status_editor2(), but with @a set_locks_baton set 4381 * to @c NULL, and taking a deprecated svn_wc_status_func_t argument. 4382 * 4383 * @deprecated Provided for backward compatibility with the 1.1 API. 4384 */ 4385SVN_DEPRECATED 4386svn_error_t * 4387svn_wc_get_status_editor(const svn_delta_editor_t **editor, 4388 void **edit_baton, 4389 svn_revnum_t *edit_revision, 4390 svn_wc_adm_access_t *anchor, 4391 const char *target, 4392 apr_hash_t *config, 4393 svn_boolean_t recurse, 4394 svn_boolean_t get_all, 4395 svn_boolean_t no_ignore, 4396 svn_wc_status_func_t status_func, 4397 void *status_baton, 4398 svn_cancel_func_t cancel_func, 4399 void *cancel_baton, 4400 svn_wc_traversal_info_t *traversal_info, 4401 apr_pool_t *pool); 4402 4403 4404/** 4405 * Associate @a locks, a hash table mapping <tt>const char*</tt> 4406 * absolute repository paths to <tt>svn_lock_t</tt> objects, with a 4407 * @a set_locks_baton returned by an earlier call to 4408 * svn_wc_get_status_editor3(). @a repos_root is the repository root URL. 4409 * Perform all allocations in @a pool. 4410 * 4411 * @note @a locks will not be copied, so it must be valid throughout the 4412 * edit. @a pool must also not be destroyed or cleared before the edit is 4413 * finished. 4414 * 4415 * @since New in 1.2. 4416 */ 4417svn_error_t * 4418svn_wc_status_set_repos_locks(void *set_locks_baton, 4419 apr_hash_t *locks, 4420 const char *repos_root, 4421 apr_pool_t *pool); 4422 4423/** @} */ 4424 4425 4426/** 4427 * Copy @a src_abspath to @a dst_abspath, and schedule @a dst_abspath 4428 * for addition to the repository, remembering the copy history. @a wc_ctx 4429 * is used for accessing the working copy and must contain a write lock for 4430 * the parent directory of @a dst_abspath, 4431 * 4432 * If @a metadata_only is TRUE then this is a database-only operation and 4433 * the working directories and files are not copied. 4434 * 4435 * @a src_abspath must be a file or directory under version control; 4436 * the parent of @a dst_abspath must be a directory under version control 4437 * in the same working copy; @a dst_abspath will be the name of the copied 4438 * item, and it must not exist already if @a metadata_only is FALSE. Note that 4439 * when @a src points to a versioned file, the working file doesn't 4440 * necessarily exist in which case its text-base is used instead. 4441 * 4442 * If @a cancel_func is non-NULL, call it with @a cancel_baton at 4443 * various points during the operation. If it returns an error 4444 * (typically #SVN_ERR_CANCELLED), return that error immediately. 4445 * 4446 * If @a notify_func is non-NULL, call it with @a notify_baton and the path 4447 * of the root node (only) of the destination. 4448 * 4449 * Use @a scratch_pool for temporary allocations. 4450 * 4451 * @since New in 1.7. 4452 */ 4453svn_error_t * 4454svn_wc_copy3(svn_wc_context_t *wc_ctx, 4455 const char *src_abspath, 4456 const char *dst_abspath, 4457 svn_boolean_t metadata_only, 4458 svn_cancel_func_t cancel_func, 4459 void *cancel_baton, 4460 svn_wc_notify_func2_t notify_func, 4461 void *notify_baton, 4462 apr_pool_t *scratch_pool); 4463 4464/** Similar to svn_wc_copy3(), but takes access batons and a relative path 4465 * and a basename instead of absolute paths and a working copy context. 4466 * 4467 * @since New in 1.2. 4468 * @deprecated Provided for backward compatibility with the 1.6 API. 4469 */ 4470SVN_DEPRECATED 4471svn_error_t * 4472svn_wc_copy2(const char *src, 4473 svn_wc_adm_access_t *dst_parent, 4474 const char *dst_basename, 4475 svn_cancel_func_t cancel_func, 4476 void *cancel_baton, 4477 svn_wc_notify_func2_t notify_func, 4478 void *notify_baton, 4479 apr_pool_t *pool); 4480 4481/** 4482 * Similar to svn_wc_copy2(), but takes an #svn_wc_notify_func_t instead. 4483 * 4484 * @deprecated Provided for backward compatibility with the 1.1 API. 4485 */ 4486SVN_DEPRECATED 4487svn_error_t * 4488svn_wc_copy(const char *src, 4489 svn_wc_adm_access_t *dst_parent, 4490 const char *dst_basename, 4491 svn_cancel_func_t cancel_func, 4492 void *cancel_baton, 4493 svn_wc_notify_func_t notify_func, 4494 void *notify_baton, 4495 apr_pool_t *pool); 4496 4497/** 4498 * Move @a src_abspath to @a dst_abspath, by scheduling @a dst_abspath 4499 * for addition to the repository, remembering the history. Mark @a src_abspath 4500 * as deleted after moving.@a wc_ctx is used for accessing the working copy and 4501 * must contain a write lock for the parent directory of @a src_abspath and 4502 * @a dst_abspath. 4503 * 4504 * If @a metadata_only is TRUE then this is a database-only operation and 4505 * the working directories and files are not changed. 4506 * 4507 * @a src_abspath must be a file or directory under version control; 4508 * the parent of @a dst_abspath must be a directory under version control 4509 * in the same working copy; @a dst_abspath will be the name of the copied 4510 * item, and it must not exist already if @a metadata_only is FALSE. Note that 4511 * when @a src points to a versioned file, the working file doesn't 4512 * necessarily exist in which case its text-base is used instead. 4513 * 4514 * If @a cancel_func is non-NULL, call it with @a cancel_baton at 4515 * various points during the operation. If it returns an error 4516 * (typically #SVN_ERR_CANCELLED), return that error immediately. 4517 * 4518 * If @a notify_func is non-NULL, call it with @a notify_baton and the path 4519 * of the root node (only) of the destination. 4520 * 4521 * Use @a scratch_pool for temporary allocations. 4522 * 4523 * @since New in 1.7. 4524 * @deprecated Provided for backward compatibility with the 1.7 API. 4525 * @see svn_client_move7() 4526 */ 4527SVN_DEPRECATED 4528svn_error_t * 4529svn_wc_move(svn_wc_context_t *wc_ctx, 4530 const char *src_abspath, 4531 const char *dst_abspath, 4532 svn_boolean_t metadata_only, 4533 svn_cancel_func_t cancel_func, 4534 void *cancel_baton, 4535 svn_wc_notify_func2_t notify_func, 4536 void *notify_baton, 4537 apr_pool_t *scratch_pool); 4538 4539/** 4540 * Schedule @a local_abspath for deletion. It will be deleted from the 4541 * repository on the next commit. If @a local_abspath refers to a 4542 * directory, then a recursive deletion will occur. @a wc_ctx must hold 4543 * a write lock for the parent of @a local_abspath, @a local_abspath itself 4544 * and everything below @a local_abspath. 4545 * 4546 * If @a keep_local is FALSE, this function immediately deletes all files, 4547 * modified and unmodified, versioned and of @a delete_unversioned is TRUE, 4548 * unversioned from the working copy. 4549 * It also immediately deletes unversioned directories and directories that 4550 * are scheduled to be added below @a local_abspath. Only versioned may 4551 * remain in the working copy, these get deleted by the update following 4552 * the commit. 4553 * 4554 * If @a keep_local is TRUE, all files and directories will be kept in the 4555 * working copy (and will become unversioned on the next commit). 4556 * 4557 * If @a delete_unversioned_target is TRUE and @a local_abspath is not 4558 * versioned, @a local_abspath will be handled as an added files without 4559 * history. So it will be deleted if @a keep_local is FALSE. If @a 4560 * delete_unversioned is FALSE and @a local_abspath is not versioned a 4561 * #SVN_ERR_WC_PATH_NOT_FOUND error will be returned. 4562 * 4563 * If @a cancel_func is non-NULL, call it with @a cancel_baton at 4564 * various points during the operation. If it returns an error 4565 * (typically #SVN_ERR_CANCELLED), return that error immediately. 4566 * 4567 * For each path marked for deletion, @a notify_func will be called with 4568 * the @a notify_baton and that path. The @a notify_func callback may be 4569 * @c NULL if notification is not needed. 4570 * 4571 * Use @a scratch_pool for temporary allocations. It may be cleared 4572 * immediately upon returning from this function. 4573 * 4574 * @since New in 1.7. 4575 */ 4576 /* ### BH: Maybe add a delete_switched flag that allows deny switched 4577 nodes like file externals? */ 4578svn_error_t * 4579svn_wc_delete4(svn_wc_context_t *wc_ctx, 4580 const char *local_abspath, 4581 svn_boolean_t keep_local, 4582 svn_boolean_t delete_unversioned_target, 4583 svn_cancel_func_t cancel_func, 4584 void *cancel_baton, 4585 svn_wc_notify_func2_t notify_func, 4586 void *notify_baton, 4587 apr_pool_t *scratch_pool); 4588 4589/** 4590 * Similar to svn_wc_delete4, but uses an access baton and relative path 4591 * instead of a working copy context and absolute path. @a adm_access 4592 * must hold a write lock for the parent of @a path. 4593 * 4594 * @c delete_unversioned_target will always be set to TRUE. 4595 * 4596 * @since New in 1.5. 4597 * @deprecated Provided for backward compatibility with the 1.6 API. 4598 */ 4599SVN_DEPRECATED 4600svn_error_t * 4601svn_wc_delete3(const char *path, 4602 svn_wc_adm_access_t *adm_access, 4603 svn_cancel_func_t cancel_func, 4604 void *cancel_baton, 4605 svn_wc_notify_func2_t notify_func, 4606 void *notify_baton, 4607 svn_boolean_t keep_local, 4608 apr_pool_t *pool); 4609 4610/** 4611 * Similar to svn_wc_delete3(), but with @a keep_local always set to FALSE. 4612 * 4613 * @deprecated Provided for backward compatibility with the 1.4 API. 4614 */ 4615SVN_DEPRECATED 4616svn_error_t * 4617svn_wc_delete2(const char *path, 4618 svn_wc_adm_access_t *adm_access, 4619 svn_cancel_func_t cancel_func, 4620 void *cancel_baton, 4621 svn_wc_notify_func2_t notify_func, 4622 void *notify_baton, 4623 apr_pool_t *pool); 4624 4625/** 4626 * Similar to svn_wc_delete2(), but takes an #svn_wc_notify_func_t instead. 4627 * 4628 * @deprecated Provided for backward compatibility with the 1.1 API. 4629 */ 4630SVN_DEPRECATED 4631svn_error_t * 4632svn_wc_delete(const char *path, 4633 svn_wc_adm_access_t *adm_access, 4634 svn_cancel_func_t cancel_func, 4635 void *cancel_baton, 4636 svn_wc_notify_func_t notify_func, 4637 void *notify_baton, 4638 apr_pool_t *pool); 4639 4640 4641/** 4642 * Schedule the single node that exists on disk at @a local_abspath for 4643 * addition to the working copy. The added node will have the properties 4644 * provided in @a props, or none if that is NULL. 4645 * 4646 * Unless @a skip_checks is TRUE, check and canonicalize the properties in the 4647 * same way as svn_wc_prop_set4(). Return an error and don't add the node if 4648 * the properties are not valid on this node. 4649 * 4650 * ### The error code on validity check failure should be specified, and 4651 * preferably should be a single code. 4652 * 4653 * The versioned state of the parent path must be a modifiable directory, 4654 * and the versioned state of @a local_abspath must be either nonexistent or 4655 * deleted; if deleted, the new node will be a replacement. 4656 * 4657 * If @a local_abspath does not exist as file, directory or symlink, return 4658 * #SVN_ERR_WC_PATH_NOT_FOUND. 4659 * 4660 * If @a notify_func is non-NULL, invoke it with @a notify_baton to report 4661 * the item being added. 4662 * 4663 * ### TODO: Split into add_dir, add_file, add_symlink? 4664 * 4665 * @since New in 1.9. 4666 */ 4667svn_error_t * 4668svn_wc_add_from_disk3(svn_wc_context_t *wc_ctx, 4669 const char *local_abspath, 4670 const apr_hash_t *props, 4671 svn_boolean_t skip_checks, 4672 svn_wc_notify_func2_t notify_func, 4673 void *notify_baton, 4674 apr_pool_t *scratch_pool); 4675 4676/** 4677 * Similar to svn_wc_add_from_disk3(), but always passes FALSE for 4678 * @a skip_checks 4679 * 4680 * @since New in 1.8. 4681 * @deprecated Provided for backward compatibility with the 1.8 API. 4682 */ 4683SVN_DEPRECATED 4684svn_error_t * 4685svn_wc_add_from_disk2(svn_wc_context_t *wc_ctx, 4686 const char *local_abspath, 4687 const apr_hash_t *props, 4688 svn_wc_notify_func2_t notify_func, 4689 void *notify_baton, 4690 apr_pool_t *scratch_pool); 4691 4692 4693/** 4694 * Similar to svn_wc_add_from_disk2(), but always passes NULL for @a 4695 * props. 4696 * 4697 * This is a replacement for svn_wc_add4() case 2a (which see for 4698 * details). 4699 4700 * @see svn_wc_add4() 4701 * 4702 * @since New in 1.7. 4703 * @deprecated Provided for backward compatibility with the 1.7 API. 4704 */ 4705SVN_DEPRECATED 4706svn_error_t * 4707svn_wc_add_from_disk(svn_wc_context_t *wc_ctx, 4708 const char *local_abspath, 4709 svn_wc_notify_func2_t notify_func, 4710 void *notify_baton, 4711 apr_pool_t *scratch_pool); 4712 4713 4714/** 4715 * Put @a local_abspath under version control by registering it as addition 4716 * or copy in the database containing its parent. The new node is scheduled 4717 * for addition to the repository below its parent node. 4718 * 4719 * 1) If the node is already versioned, it MUST BE the root of a separate 4720 * working copy from the same repository as the parent WC. The new node 4721 * and anything below it will be scheduled for addition inside the parent 4722 * working copy as a copy of the original location. The separate working 4723 * copy will be integrated by this step. In this case, which is only used 4724 * by code like that of "svn cp URL@rev path" @a copyfrom_url and 4725 * @a copyfrom_rev MUST BE the url and revision of @a local_abspath 4726 * in the separate working copy. 4727 * 4728 * 2a) If the node was not versioned before it will be scheduled as a local 4729 * addition or 2b) if @a copyfrom_url and @a copyfrom_rev are set as a copy 4730 * of that location. In this last case the function doesn't set the pristine 4731 * version (of a file) and/or pristine properties, which callers should 4732 * handle via different APIs. Usually it is easier to call 4733 * svn_wc_add_repos_file4() (### or a possible svn_wc_add_repos_dir()) than 4734 * using this variant. 4735 * 4736 * If @a local_abspath does not exist as file, directory or symlink, return 4737 * #SVN_ERR_WC_PATH_NOT_FOUND. 4738 * 4739 * If @a local_abspath is an unversioned directory, record @a depth on it; 4740 * otherwise, ignore @a depth. (Use #svn_depth_infinity unless you exactly 4741 * know what you are doing, or you may create an unexpected sparse working 4742 * copy) 4743 * 4744 * If @a cancel_func is non-NULL, call it with @a cancel_baton at 4745 * various points during the operation. If it returns an error 4746 * (typically #SVN_ERR_CANCELLED), return that error immediately. 4747 * 4748 * When the @a local_abspath has been added, then @a notify_func will be 4749 * called (if it is not @c NULL) with the @a notify_baton and the path. 4750 * 4751 * @note Case 1 is deprecated. Consider doing a WC-to-WC copy instead. 4752 * @note For case 2a, prefer svn_wc_add_from_disk(). 4753 * 4754 * @since New in 1.7. 4755 */ 4756svn_error_t * 4757svn_wc_add4(svn_wc_context_t *wc_ctx, 4758 const char *local_abspath, 4759 svn_depth_t depth, 4760 const char *copyfrom_url, 4761 svn_revnum_t copyfrom_rev, 4762 svn_cancel_func_t cancel_func, 4763 void *cancel_baton, 4764 svn_wc_notify_func2_t notify_func, 4765 void *notify_baton, 4766 apr_pool_t *scratch_pool); 4767 4768/** 4769 * Similar to svn_wc_add4(), but with an access baton 4770 * and relative path instead of a context and absolute path. 4771 * @since New in 1.6. 4772 * @deprecated Provided for backward compatibility with the 1.6 API. 4773 */ 4774SVN_DEPRECATED 4775svn_error_t * 4776svn_wc_add3(const char *path, 4777 svn_wc_adm_access_t *parent_access, 4778 svn_depth_t depth, 4779 const char *copyfrom_url, 4780 svn_revnum_t copyfrom_rev, 4781 svn_cancel_func_t cancel_func, 4782 void *cancel_baton, 4783 svn_wc_notify_func2_t notify_func, 4784 void *notify_baton, 4785 apr_pool_t *pool); 4786 4787/** 4788 * Similar to svn_wc_add3(), but with the @a depth parameter always 4789 * #svn_depth_infinity. 4790 * 4791 * @since New in 1.2. 4792 * @deprecated Provided for backward compatibility with the 1.5 API. 4793 */ 4794SVN_DEPRECATED 4795svn_error_t * 4796svn_wc_add2(const char *path, 4797 svn_wc_adm_access_t *parent_access, 4798 const char *copyfrom_url, 4799 svn_revnum_t copyfrom_rev, 4800 svn_cancel_func_t cancel_func, 4801 void *cancel_baton, 4802 svn_wc_notify_func2_t notify_func, 4803 void *notify_baton, 4804 apr_pool_t *pool); 4805 4806/** 4807 * Similar to svn_wc_add2(), but takes an #svn_wc_notify_func_t instead. 4808 * 4809 * @deprecated Provided for backward compatibility with the 1.1 API. 4810 */ 4811SVN_DEPRECATED 4812svn_error_t * 4813svn_wc_add(const char *path, 4814 svn_wc_adm_access_t *parent_access, 4815 const char *copyfrom_url, 4816 svn_revnum_t copyfrom_rev, 4817 svn_cancel_func_t cancel_func, 4818 void *cancel_baton, 4819 svn_wc_notify_func_t notify_func, 4820 void *notify_baton, 4821 apr_pool_t *pool); 4822 4823/** Add a file to a working copy at @a local_abspath, obtaining the 4824 * text-base's contents from @a new_base_contents, the wc file's 4825 * content from @a new_contents, its unmodified properties from @a 4826 * new_base_props and its actual properties from @a new_props. Use 4827 * @a wc_ctx for accessing the working copy. 4828 * 4829 * The unmodified text and props normally come from the repository 4830 * file represented by the copyfrom args, see below. The new file 4831 * will be marked as copy. 4832 * 4833 * @a new_contents and @a new_props may be NULL, in which case 4834 * the working copy text and props are taken from the base files with 4835 * appropriate translation of the file's content. 4836 * 4837 * @a new_contents must be provided in Normal Form. This is required 4838 * in order to pass both special and non-special files through a stream. 4839 * 4840 * @a wc_ctx must contain a write lock for the parent of @a local_abspath. 4841 * 4842 * If @a copyfrom_url is non-NULL, then @a copyfrom_rev must be a 4843 * valid revision number, and together they are the copyfrom history 4844 * for the new file. 4845 * 4846 * The @a cancel_func and @a cancel_baton are a standard cancellation 4847 * callback, or NULL if no callback is needed. @a notify_func and 4848 * @a notify_baton are a notification callback, and (if not NULL) 4849 * will be notified of the addition of this file. 4850 * 4851 * Use @a scratch_pool for temporary allocations. 4852 * 4853 * ### This function is very redundant with svn_wc_add(). Ideally, 4854 * we'd merge them, so that svn_wc_add() would just take optional 4855 * new_props and optional copyfrom information. That way it could be 4856 * used for both 'svn add somefilesittingonmydisk' and for adding 4857 * files from repositories, with or without copyfrom history. 4858 * 4859 * The problem with this Ideal Plan is that svn_wc_add() also takes 4860 * care of recursive URL-rewriting. There's a whole comment in its 4861 * doc string about how that's really weird, outside its core mission, 4862 * etc, etc. So another part of the Ideal Plan is that that 4863 * functionality of svn_wc_add() would move into a separate function. 4864 * 4865 * @since New in 1.7. 4866 */ 4867svn_error_t * 4868svn_wc_add_repos_file4(svn_wc_context_t *wc_ctx, 4869 const char *local_abspath, 4870 svn_stream_t *new_base_contents, 4871 svn_stream_t *new_contents, 4872 apr_hash_t *new_base_props, 4873 apr_hash_t *new_props, 4874 const char *copyfrom_url, 4875 svn_revnum_t copyfrom_rev, 4876 svn_cancel_func_t cancel_func, 4877 void *cancel_baton, 4878 apr_pool_t *scratch_pool); 4879 4880/** Similar to svn_wc_add_repos_file4, but uses access batons and a 4881 * relative path instead of a working copy context and absolute path. 4882 * 4883 * ### NOTE: the notification callback/baton is not yet used. 4884 * 4885 * @since New in 1.6. 4886 * @deprecated Provided for compatibility with the 1.6 API. 4887 */ 4888SVN_DEPRECATED 4889svn_error_t * 4890svn_wc_add_repos_file3(const char *dst_path, 4891 svn_wc_adm_access_t *adm_access, 4892 svn_stream_t *new_base_contents, 4893 svn_stream_t *new_contents, 4894 apr_hash_t *new_base_props, 4895 apr_hash_t *new_props, 4896 const char *copyfrom_url, 4897 svn_revnum_t copyfrom_rev, 4898 svn_cancel_func_t cancel_func, 4899 void *cancel_baton, 4900 svn_wc_notify_func2_t notify_func, 4901 void *notify_baton, 4902 apr_pool_t *scratch_pool); 4903 4904 4905/** Same as svn_wc_add_repos_file3(), except that it has pathnames rather 4906 * than streams for the text base, and actual text, and has no cancellation. 4907 * 4908 * @since New in 1.4. 4909 * @deprecated Provided for compatibility with the 1.5 API 4910 */ 4911SVN_DEPRECATED 4912svn_error_t * 4913svn_wc_add_repos_file2(const char *dst_path, 4914 svn_wc_adm_access_t *adm_access, 4915 const char *new_text_base_path, 4916 const char *new_text_path, 4917 apr_hash_t *new_base_props, 4918 apr_hash_t *new_props, 4919 const char *copyfrom_url, 4920 svn_revnum_t copyfrom_rev, 4921 apr_pool_t *pool); 4922 4923/** Same as svn_wc_add_repos_file3(), except that it doesn't have the 4924 * BASE arguments or cancellation. 4925 * 4926 * @deprecated Provided for compatibility with the 1.3 API 4927 */ 4928SVN_DEPRECATED 4929svn_error_t * 4930svn_wc_add_repos_file(const char *dst_path, 4931 svn_wc_adm_access_t *adm_access, 4932 const char *new_text_path, 4933 apr_hash_t *new_props, 4934 const char *copyfrom_url, 4935 svn_revnum_t copyfrom_rev, 4936 apr_pool_t *pool); 4937 4938 4939/** Remove @a local_abspath from revision control. @a wc_ctx must 4940 * hold a write lock on the parent of @a local_abspath, or if that is a 4941 * WC root then on @a local_abspath itself. 4942 * 4943 * If @a local_abspath is a file, all its info will be removed from the 4944 * administrative area. If @a local_abspath is a directory, then the 4945 * administrative area will be deleted, along with *all* the administrative 4946 * areas anywhere in the tree below @a adm_access. 4947 * 4948 * Normally, only administrative data is removed. However, if 4949 * @a destroy_wf is TRUE, then all working file(s) and dirs are deleted 4950 * from disk as well. When called with @a destroy_wf, any locally 4951 * modified files will *not* be deleted, and the special error 4952 * #SVN_ERR_WC_LEFT_LOCAL_MOD might be returned. (Callers only need to 4953 * check for this special return value if @a destroy_wf is TRUE.) 4954 * 4955 * If @a instant_error is TRUE, then return 4956 * #SVN_ERR_WC_LEFT_LOCAL_MOD the instant a locally modified file is 4957 * encountered. Otherwise, leave locally modified files in place and 4958 * return the error only after all the recursion is complete. 4959 * 4960 * If @a cancel_func is non-NULL, call it with @a cancel_baton at 4961 * various points during the removal. If it returns an error 4962 * (typically #SVN_ERR_CANCELLED), return that error immediately. 4963 * 4964 * WARNING: This routine is exported for careful, measured use by 4965 * libsvn_client. Do *not* call this routine unless you really 4966 * understand what the heck you're doing. 4967 * 4968 * @since New in 1.7. 4969 */ 4970svn_error_t * 4971svn_wc_remove_from_revision_control2(svn_wc_context_t *wc_ctx, 4972 const char *local_abspath, 4973 svn_boolean_t destroy_wf, 4974 svn_boolean_t instant_error, 4975 svn_cancel_func_t cancel_func, 4976 void *cancel_baton, 4977 apr_pool_t *pool); 4978 4979/** 4980 * Similar to svn_wc_remove_from_revision_control2() but with a name 4981 * and access baton. 4982 * 4983 * WARNING: This routine was exported for careful, measured use by 4984 * libsvn_client. Do *not* call this routine unless you really 4985 * understand what the heck you're doing. 4986 * 4987 * @deprecated Provided for compatibility with the 1.6 API 4988 */ 4989SVN_DEPRECATED 4990svn_error_t * 4991svn_wc_remove_from_revision_control(svn_wc_adm_access_t *adm_access, 4992 const char *name, 4993 svn_boolean_t destroy_wf, 4994 svn_boolean_t instant_error, 4995 svn_cancel_func_t cancel_func, 4996 void *cancel_baton, 4997 apr_pool_t *pool); 4998 4999 5000/** 5001 * Assuming @a local_abspath is under version control or a tree conflict 5002 * victim and in a state of conflict, then take @a local_abspath *out* 5003 * of this state. If @a resolve_text is TRUE then any text conflict is 5004 * resolved, if @a resolve_tree is TRUE then any tree conflicts are 5005 * resolved. If @a resolve_prop is set to "" all property conflicts are 5006 * resolved, if it is set to any other string value, conflicts on that 5007 * specific property are resolved and when resolve_prop is NULL, no 5008 * property conflicts are resolved. 5009 * 5010 * If @a depth is #svn_depth_empty, act only on @a local_abspath; if 5011 * #svn_depth_files, resolve @a local_abspath and its conflicted file 5012 * children (if any); if #svn_depth_immediates, resolve @a local_abspath 5013 * and all its immediate conflicted children (both files and directories, 5014 * if any); if #svn_depth_infinity, resolve @a local_abspath and every 5015 * conflicted file or directory anywhere beneath it. 5016 * 5017 * If @a conflict_choice is #svn_wc_conflict_choose_base, resolve the 5018 * conflict with the old file contents; if 5019 * #svn_wc_conflict_choose_mine_full, use the original working contents; 5020 * if #svn_wc_conflict_choose_theirs_full, the new contents; and if 5021 * #svn_wc_conflict_choose_merged, don't change the contents at all, 5022 * just remove the conflict status, which is the pre-1.5 behavior. 5023 * 5024 * #svn_wc_conflict_choose_theirs_conflict and 5025 * #svn_wc_conflict_choose_mine_conflict are not legal for binary 5026 * files or properties. 5027 * 5028 * @a wc_ctx is a working copy context, with a write lock, for @a 5029 * local_abspath. 5030 * 5031 * Needless to say, this function doesn't touch conflict markers or 5032 * anything of that sort -- only a human can semantically resolve a 5033 * conflict. Instead, this function simply marks a file as "having 5034 * been resolved", clearing the way for a commit. 5035 * 5036 * The implementation details are opaque, as our "conflicted" criteria 5037 * might change over time. (At the moment, this routine removes the 5038 * three fulltext 'backup' files and any .prej file created in a conflict, 5039 * and modifies @a local_abspath's entry.) 5040 * 5041 * If @a local_abspath is not under version control and not a tree 5042 * conflict, return #SVN_ERR_ENTRY_NOT_FOUND. If @a path isn't in a 5043 * state of conflict to begin with, do nothing, and return #SVN_NO_ERROR. 5044 * 5045 * If @c local_abspath was successfully taken out of a state of conflict, 5046 * report this information to @c notify_func (if non-@c NULL.) If only 5047 * text, only property, or only tree conflict resolution was requested, 5048 * and it was successful, then success gets reported. 5049 * 5050 * Temporary allocations will be performed in @a scratch_pool. 5051 * 5052 * @since New in 1.7. 5053 */ 5054svn_error_t * 5055svn_wc_resolved_conflict5(svn_wc_context_t *wc_ctx, 5056 const char *local_abspath, 5057 svn_depth_t depth, 5058 svn_boolean_t resolve_text, 5059 const char *resolve_prop, 5060 svn_boolean_t resolve_tree, 5061 svn_wc_conflict_choice_t conflict_choice, 5062 svn_cancel_func_t cancel_func, 5063 void *cancel_baton, 5064 svn_wc_notify_func2_t notify_func, 5065 void *notify_baton, 5066 apr_pool_t *scratch_pool); 5067 5068/** Similar to svn_wc_resolved_conflict5, but takes an absolute path 5069 * and an access baton. This version doesn't support resolving a specific 5070 * property.conflict. 5071 * 5072 * @since New in 1.6. 5073 * @deprecated Provided for backward compatibility with the 1.6 API. 5074 */ 5075SVN_DEPRECATED 5076svn_error_t * 5077svn_wc_resolved_conflict4(const char *path, 5078 svn_wc_adm_access_t *adm_access, 5079 svn_boolean_t resolve_text, 5080 svn_boolean_t resolve_props, 5081 svn_boolean_t resolve_tree, 5082 svn_depth_t depth, 5083 svn_wc_conflict_choice_t conflict_choice, 5084 svn_wc_notify_func2_t notify_func, 5085 void *notify_baton, 5086 svn_cancel_func_t cancel_func, 5087 void *cancel_baton, 5088 apr_pool_t *pool); 5089 5090 5091/** 5092 * Similar to svn_wc_resolved_conflict4(), but without tree-conflict 5093 * resolution support. 5094 * 5095 * @since New in 1.5. 5096 * @deprecated Provided for backward compatibility with the 1.5 API. 5097 */ 5098SVN_DEPRECATED 5099svn_error_t * 5100svn_wc_resolved_conflict3(const char *path, 5101 svn_wc_adm_access_t *adm_access, 5102 svn_boolean_t resolve_text, 5103 svn_boolean_t resolve_props, 5104 svn_depth_t depth, 5105 svn_wc_conflict_choice_t conflict_choice, 5106 svn_wc_notify_func2_t notify_func, 5107 void *notify_baton, 5108 svn_cancel_func_t cancel_func, 5109 void *cancel_baton, 5110 apr_pool_t *pool); 5111 5112 5113/** 5114 * Similar to svn_wc_resolved_conflict3(), but without automatic conflict 5115 * resolution support, and with @a depth set according to @a recurse: 5116 * if @a recurse is TRUE, @a depth is #svn_depth_infinity, else it is 5117 * #svn_depth_files. 5118 * 5119 * @since New in 1.2. 5120 * @deprecated Provided for backward compatibility with the 1.4 API. 5121 */ 5122SVN_DEPRECATED 5123svn_error_t * 5124svn_wc_resolved_conflict2(const char *path, 5125 svn_wc_adm_access_t *adm_access, 5126 svn_boolean_t resolve_text, 5127 svn_boolean_t resolve_props, 5128 svn_boolean_t recurse, 5129 svn_wc_notify_func2_t notify_func, 5130 void *notify_baton, 5131 svn_cancel_func_t cancel_func, 5132 void *cancel_baton, 5133 apr_pool_t *pool); 5134 5135/** 5136 * Similar to svn_wc_resolved_conflict2(), but takes an 5137 * svn_wc_notify_func_t and doesn't have cancellation support. 5138 * 5139 * @deprecated Provided for backward compatibility with the 1.1 API. 5140 */ 5141SVN_DEPRECATED 5142svn_error_t * 5143svn_wc_resolved_conflict(const char *path, 5144 svn_wc_adm_access_t *adm_access, 5145 svn_boolean_t resolve_text, 5146 svn_boolean_t resolve_props, 5147 svn_boolean_t recurse, 5148 svn_wc_notify_func_t notify_func, 5149 void *notify_baton, 5150 apr_pool_t *pool); 5151 5152 5153/* Commits. */ 5154 5155 5156/** 5157 * Storage type for queued post-commit data. 5158 * 5159 * @since New in 1.5. 5160 */ 5161typedef struct svn_wc_committed_queue_t svn_wc_committed_queue_t; 5162 5163 5164/** 5165 * Create a queue for use with svn_wc_queue_committed() and 5166 * svn_wc_process_committed_queue(). 5167 * 5168 * The returned queue and all further allocations required for queuing 5169 * new items will also be done from @a pool. 5170 * 5171 * @since New in 1.5. 5172 */ 5173svn_wc_committed_queue_t * 5174svn_wc_committed_queue_create(apr_pool_t *pool); 5175 5176 5177/** 5178 * Queue committed items to be processed later by 5179 * svn_wc_process_committed_queue2(). 5180 * 5181 * Record in @a queue that @a local_abspath will need to be bumped 5182 * after a commit succeeds. 5183 * 5184 * If non-NULL, @a wcprop_changes is an array of <tt>svn_prop_t *</tt> 5185 * changes to wc properties; if an #svn_prop_t->value is NULL, then 5186 * that property is deleted. 5187 * ### [JAF] No, a prop whose value is NULL is ignored, not deleted. This 5188 * ### seems to be not a set of changes but rather the new complete set of 5189 * ### props. And it's renamed to 'new_dav_cache' inside; why? 5190 * 5191 * If @a is_committed is @c TRUE, the node will be processed as committed. This 5192 * turns the node and its implied descendants as the new unmodified state at 5193 * the new specified revision. Unless @a recurse is TRUE, changes on 5194 * descendants are not committed as changes directly. In this case they should 5195 * be queueud as their own changes. 5196 * 5197 * If @a remove_lock is @c TRUE, any entryprops related to a repository 5198 * lock will be removed. 5199 * 5200 * If @a remove_changelist is @c TRUE, any association with a 5201 * changelist will be removed. 5202 * 5203 * 5204 * If @a sha1_checksum is non-NULL, use it to identify the node's pristine 5205 * text. 5206 * 5207 * If @a recurse is TRUE and @a local_abspath is a directory, then bump every 5208 * versioned object at or under @a local_abspath. This is usually done for 5209 * copied trees. 5210 * 5211 * ### In the present implementation, if a recursive directory item is in 5212 * the queue, then any children (at any depth) of that directory that 5213 * are also in the queue as separate items will get: 5214 * 'wcprop_changes' = NULL; 5215 * 'remove_lock' = FALSE; 5216 * 'remove_changelist' from the recursive parent item; 5217 * and any children (at any depth) of that directory that are NOT in 5218 * the queue as separate items will get: 5219 * 'wcprop_changes' = NULL; 5220 * 'remove_lock' = FALSE; 5221 * 'remove_changelist' from the recursive parent item; 5222 * 5223 * @note the @a recurse parameter should be used with extreme care since 5224 * it will bump ALL nodes under the directory, regardless of their 5225 * actual inclusion in the new revision. 5226 * 5227 * All pointer data passed to this function (@a local_abspath, 5228 * @a wcprop_changes and the checksums) should remain valid until the 5229 * queue has been processed by svn_wc_process_committed_queue2(). 5230 * 5231 * Temporary allocations will be performed in @a scratch_pool, and persistent 5232 * allocations will use the same pool as @a queue used when it was created. 5233 * 5234 * @since New in 1.9. 5235 */ 5236svn_error_t * 5237svn_wc_queue_committed4(svn_wc_committed_queue_t *queue, 5238 svn_wc_context_t *wc_ctx, 5239 const char *local_abspath, 5240 svn_boolean_t recurse, 5241 svn_boolean_t is_committed, 5242 const apr_array_header_t *wcprop_changes, 5243 svn_boolean_t remove_lock, 5244 svn_boolean_t remove_changelist, 5245 const svn_checksum_t *sha1_checksum, 5246 apr_pool_t *scratch_pool); 5247 5248/** Similar to svn_wc_queue_committed4, but with is_committed always 5249 * TRUE. 5250 * 5251 * @since New in 1.7. 5252 * @deprecated Provided for backwards compatibility with the 1.8 API. 5253 */ 5254svn_error_t * 5255svn_wc_queue_committed3(svn_wc_committed_queue_t *queue, 5256 svn_wc_context_t *wc_ctx, 5257 const char *local_abspath, 5258 svn_boolean_t recurse, 5259 const apr_array_header_t *wcprop_changes, 5260 svn_boolean_t remove_lock, 5261 svn_boolean_t remove_changelist, 5262 const svn_checksum_t *sha1_checksum, 5263 apr_pool_t *scratch_pool); 5264 5265/** Same as svn_wc_queue_committed3() except @a path doesn't have to be an 5266 * abspath and @a adm_access is unused and a SHA-1 checksum cannot be 5267 * specified. 5268 * 5269 * @since New in 1.6. 5270 * 5271 * @deprecated Provided for backwards compatibility with the 1.6 API. 5272 */ 5273SVN_DEPRECATED 5274svn_error_t * 5275svn_wc_queue_committed2(svn_wc_committed_queue_t *queue, 5276 const char *path, 5277 svn_wc_adm_access_t *adm_access, 5278 svn_boolean_t recurse, 5279 const apr_array_header_t *wcprop_changes, 5280 svn_boolean_t remove_lock, 5281 svn_boolean_t remove_changelist, 5282 const svn_checksum_t *md5_checksum, 5283 apr_pool_t *scratch_pool); 5284 5285 5286/** Same as svn_wc_queue_committed2() but the @a queue parameter has an 5287 * extra indirection and @a digest is supplied instead of a checksum type. 5288 * 5289 * @note despite the extra indirection, this function does NOT allocate 5290 * the queue for you. svn_wc_committed_queue_create() must be called. 5291 * 5292 * @since New in 1.5 5293 * 5294 * @deprecated Provided for backwards compatibility with 1.5 5295 */ 5296SVN_DEPRECATED 5297svn_error_t * 5298svn_wc_queue_committed(svn_wc_committed_queue_t **queue, 5299 const char *path, 5300 svn_wc_adm_access_t *adm_access, 5301 svn_boolean_t recurse, 5302 const apr_array_header_t *wcprop_changes, 5303 svn_boolean_t remove_lock, 5304 svn_boolean_t remove_changelist, 5305 const unsigned char *digest, 5306 apr_pool_t *pool); 5307 5308 5309/** 5310 * Bump all items in @a queue to @a new_revnum after a commit succeeds. 5311 * @a rev_date and @a rev_author are the (server-side) date and author 5312 * of the new revision; one or both may be @c NULL. 5313 * 5314 * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine 5315 * if the client wants to cancel the operation. 5316 * 5317 * @since New in 1.7. 5318 */ 5319svn_error_t * 5320svn_wc_process_committed_queue2(svn_wc_committed_queue_t *queue, 5321 svn_wc_context_t *wc_ctx, 5322 svn_revnum_t new_revnum, 5323 const char *rev_date, 5324 const char *rev_author, 5325 svn_cancel_func_t cancel_func, 5326 void *cancel_baton, 5327 apr_pool_t *scratch_pool); 5328 5329/** @see svn_wc_process_committed_queue2() 5330 * 5331 * @since New in 1.5. 5332 * @deprecated Provided for backwards compatibility with the 1.6 API. 5333 */ 5334SVN_DEPRECATED 5335svn_error_t * 5336svn_wc_process_committed_queue(svn_wc_committed_queue_t *queue, 5337 svn_wc_adm_access_t *adm_access, 5338 svn_revnum_t new_revnum, 5339 const char *rev_date, 5340 const char *rev_author, 5341 apr_pool_t *pool); 5342 5343 5344/** 5345 * @note this function has improper expectations around the operation and 5346 * execution of other parts of the Subversion WC library. The resulting 5347 * coupling makes this interface near-impossible to support. Documentation 5348 * has been removed, as a result. 5349 * 5350 * @deprecated Use the svn_wc_committed_queue_* functions instead. Provided 5351 * for backwards compatibility with the 1.5 API. 5352 */ 5353SVN_DEPRECATED 5354svn_error_t * 5355svn_wc_process_committed4(const char *path, 5356 svn_wc_adm_access_t *adm_access, 5357 svn_boolean_t recurse, 5358 svn_revnum_t new_revnum, 5359 const char *rev_date, 5360 const char *rev_author, 5361 const apr_array_header_t *wcprop_changes, 5362 svn_boolean_t remove_lock, 5363 svn_boolean_t remove_changelist, 5364 const unsigned char *digest, 5365 apr_pool_t *pool); 5366 5367/** @see svn_wc_process_committed4() 5368 * 5369 * @deprecated Use the svn_wc_committed_queue_* functions instead. Provided 5370 * for backwards compatibility with the 1.4 API. 5371 */ 5372SVN_DEPRECATED 5373svn_error_t * 5374svn_wc_process_committed3(const char *path, 5375 svn_wc_adm_access_t *adm_access, 5376 svn_boolean_t recurse, 5377 svn_revnum_t new_revnum, 5378 const char *rev_date, 5379 const char *rev_author, 5380 const apr_array_header_t *wcprop_changes, 5381 svn_boolean_t remove_lock, 5382 const unsigned char *digest, 5383 apr_pool_t *pool); 5384 5385/** @see svn_wc_process_committed4() 5386 * 5387 * @deprecated Use the svn_wc_committed_queue_* functions instead. Provided 5388 * for backwards compatibility with the 1.3 API. 5389 */ 5390SVN_DEPRECATED 5391svn_error_t * 5392svn_wc_process_committed2(const char *path, 5393 svn_wc_adm_access_t *adm_access, 5394 svn_boolean_t recurse, 5395 svn_revnum_t new_revnum, 5396 const char *rev_date, 5397 const char *rev_author, 5398 const apr_array_header_t *wcprop_changes, 5399 svn_boolean_t remove_lock, 5400 apr_pool_t *pool); 5401 5402/** @see svn_wc_process_committed4() 5403 * 5404 * @deprecated Use the svn_wc_committed_queue_* functions instead. Provided 5405 * for backward compatibility with the 1.1 API. 5406 */ 5407SVN_DEPRECATED 5408svn_error_t * 5409svn_wc_process_committed(const char *path, 5410 svn_wc_adm_access_t *adm_access, 5411 svn_boolean_t recurse, 5412 svn_revnum_t new_revnum, 5413 const char *rev_date, 5414 const char *rev_author, 5415 const apr_array_header_t *wcprop_changes, 5416 apr_pool_t *pool); 5417 5418 5419 5420 5421 5422/** 5423 * Do a depth-first crawl in a working copy, beginning at @a local_abspath, 5424 * using @a wc_ctx for accessing the working copy. 5425 * 5426 * Communicate the `state' of the working copy's revisions and depths 5427 * to @a reporter/@a report_baton. Obviously, if @a local_abspath is a 5428 * file instead of a directory, this depth-first crawl will be a short one. 5429 * 5430 * No locks or logs are created, nor are any animals harmed in the 5431 * process unless @a restore_files is TRUE. No cleanup is necessary. 5432 * 5433 * After all revisions are reported, @a reporter->finish_report() is 5434 * called, which immediately causes the RA layer to update the working 5435 * copy. Thus the return value may very well reflect the result of 5436 * the update! 5437 * 5438 * If @a depth is #svn_depth_empty, then report state only for 5439 * @a path itself. If #svn_depth_files, do the same and include 5440 * immediate file children of @a path. If #svn_depth_immediates, 5441 * then behave as if for #svn_depth_files but also report the 5442 * property states of immediate subdirectories. If @a depth is 5443 * #svn_depth_infinity, then report state fully recursively. All 5444 * descents are only as deep as @a path's own depth permits, of 5445 * course. If @a depth is #svn_depth_unknown, then just use 5446 * #svn_depth_infinity, which in practice means depth of @a path. 5447 * 5448 * Iff @a honor_depth_exclude is TRUE, the crawler will report paths 5449 * whose ambient depth is #svn_depth_exclude as being excluded, and 5450 * thus prevent the server from pushing update data for those paths; 5451 * therefore, don't set this flag if you wish to pull in excluded paths. 5452 * Note that #svn_depth_exclude on the target @a path is never 5453 * honored, even if @a honor_depth_exclude is TRUE, because we need to 5454 * be able to explicitly pull in a target. For example, if this is 5455 * the working copy... 5456 * 5457 * svn co greek_tree_repos wc_dir 5458 * svn up --set-depth exclude wc_dir/A/B/E # now A/B/E is excluded 5459 * 5460 * ...then 'svn up wc_dir/A/B' would report E as excluded (assuming 5461 * @a honor_depth_exclude is TRUE), but 'svn up wc_dir/A/B/E' would 5462 * not, because the latter is trying to explicitly pull in E. In 5463 * general, we never report the update target as excluded. 5464 * 5465 * Iff @a depth_compatibility_trick is TRUE, then set the @c start_empty 5466 * flag on @a reporter->set_path() and @a reporter->link_path() calls 5467 * as necessary to trick a pre-1.5 (i.e., depth-unaware) server into 5468 * sending back all the items the client might need to upgrade a 5469 * working copy from a shallower depth to a deeper one. 5470 * 5471 * If @a restore_files is TRUE, then unexpectedly missing working files 5472 * will be restored from the administrative directory's cache. For each 5473 * file restored, the @a notify_func function will be called with the 5474 * @a notify_baton and the path of the restored file. @a notify_func may 5475 * be @c NULL if this notification is not required. If @a 5476 * use_commit_times is TRUE, then set restored files' timestamps to 5477 * their last-commit-times. 5478 * 5479 * @since New in 1.7. 5480 */ 5481svn_error_t * 5482svn_wc_crawl_revisions5(svn_wc_context_t *wc_ctx, 5483 const char *local_abspath, 5484 const svn_ra_reporter3_t *reporter, 5485 void *report_baton, 5486 svn_boolean_t restore_files, 5487 svn_depth_t depth, 5488 svn_boolean_t honor_depth_exclude, 5489 svn_boolean_t depth_compatibility_trick, 5490 svn_boolean_t use_commit_times, 5491 svn_cancel_func_t cancel_func, 5492 void *cancel_baton, 5493 svn_wc_notify_func2_t notify_func, 5494 void *notify_baton, 5495 apr_pool_t *scratch_pool); 5496 5497/** 5498 * Similar to svn_wc_crawl_revisions5, but with a relative path and 5499 * access baton instead of an absolute path and wc_ctx. 5500 * 5501 * Passes NULL for @a cancel_func and @a cancel_baton. 5502 * 5503 * @since New in 1.6. 5504 * @deprecated Provided for compatibility with the 1.6 API. 5505 */ 5506SVN_DEPRECATED 5507svn_error_t * 5508svn_wc_crawl_revisions4(const char *path, 5509 svn_wc_adm_access_t *adm_access, 5510 const svn_ra_reporter3_t *reporter, 5511 void *report_baton, 5512 svn_boolean_t restore_files, 5513 svn_depth_t depth, 5514 svn_boolean_t honor_depth_exclude, 5515 svn_boolean_t depth_compatibility_trick, 5516 svn_boolean_t use_commit_times, 5517 svn_wc_notify_func2_t notify_func, 5518 void *notify_baton, 5519 svn_wc_traversal_info_t *traversal_info, 5520 apr_pool_t *pool); 5521 5522 5523/** 5524 * Similar to svn_wc_crawl_revisions4, but with @a honor_depth_exclude always 5525 * set to false. 5526 * 5527 * @deprecated Provided for compatibility with the 1.5 API. 5528 */ 5529SVN_DEPRECATED 5530svn_error_t * 5531svn_wc_crawl_revisions3(const char *path, 5532 svn_wc_adm_access_t *adm_access, 5533 const svn_ra_reporter3_t *reporter, 5534 void *report_baton, 5535 svn_boolean_t restore_files, 5536 svn_depth_t depth, 5537 svn_boolean_t depth_compatibility_trick, 5538 svn_boolean_t use_commit_times, 5539 svn_wc_notify_func2_t notify_func, 5540 void *notify_baton, 5541 svn_wc_traversal_info_t *traversal_info, 5542 apr_pool_t *pool); 5543 5544/** 5545 * Similar to svn_wc_crawl_revisions3, but taking svn_ra_reporter2_t 5546 * instead of svn_ra_reporter3_t, and therefore only able to report 5547 * #svn_depth_infinity for depths; and taking @a recurse instead of @a 5548 * depth; and with @a depth_compatibility_trick always false. 5549 * 5550 * @deprecated Provided for compatibility with the 1.4 API. 5551 */ 5552SVN_DEPRECATED 5553svn_error_t * 5554svn_wc_crawl_revisions2(const char *path, 5555 svn_wc_adm_access_t *adm_access, 5556 const svn_ra_reporter2_t *reporter, 5557 void *report_baton, 5558 svn_boolean_t restore_files, 5559 svn_boolean_t recurse, 5560 svn_boolean_t use_commit_times, 5561 svn_wc_notify_func2_t notify_func, 5562 void *notify_baton, 5563 svn_wc_traversal_info_t *traversal_info, 5564 apr_pool_t *pool); 5565 5566/** 5567 * Similar to svn_wc_crawl_revisions2(), but takes an #svn_wc_notify_func_t 5568 * and a #svn_ra_reporter_t instead. 5569 * 5570 * @deprecated Provided for backward compatibility with the 1.1 API. 5571 */ 5572SVN_DEPRECATED 5573svn_error_t * 5574svn_wc_crawl_revisions(const char *path, 5575 svn_wc_adm_access_t *adm_access, 5576 const svn_ra_reporter_t *reporter, 5577 void *report_baton, 5578 svn_boolean_t restore_files, 5579 svn_boolean_t recurse, 5580 svn_boolean_t use_commit_times, 5581 svn_wc_notify_func_t notify_func, 5582 void *notify_baton, 5583 svn_wc_traversal_info_t *traversal_info, 5584 apr_pool_t *pool); 5585 5586 5587/** 5588 * @defgroup svn_wc_roots Working copy roots 5589 * @{ 5590 */ 5591 5592/** If @a is_wcroot is not @c NULL, set @a *is_wcroot to @c TRUE if @a 5593 * local_abspath is the root of the working copy, otherwise to @c FALSE. 5594 * 5595 * If @a is_switched is not @c NULL, set @a *is_switched to @c TRUE if @a 5596 * local_abspath is not the root of the working copy, and switched against its 5597 * parent. 5598 * 5599 * If @a kind is not @c NULL, set @a *kind to the node kind of @a 5600 * local_abspath. 5601 * 5602 * Use @a scratch_pool for any temporary allocations. 5603 * 5604 * @since New in 1.8. 5605 */ 5606svn_error_t * 5607svn_wc_check_root(svn_boolean_t *is_wcroot, 5608 svn_boolean_t *is_switched, 5609 svn_node_kind_t *kind, 5610 svn_wc_context_t *wc_ctx, 5611 const char *local_abspath, 5612 apr_pool_t *scratch_pool); 5613 5614/** Set @a *wc_root to @c TRUE if @a local_abspath represents a "working copy 5615 * root", @c FALSE otherwise. Here, @a local_abspath is a "working copy root" 5616 * if its parent directory is not a WC or if it is switched. Also, a deleted 5617 * tree-conflict victim is considered a "working copy root" because it has no 5618 * URL. 5619 * 5620 * If @a local_abspath is not found, return the error #SVN_ERR_ENTRY_NOT_FOUND. 5621 * 5622 * Use @a scratch_pool for any temporary allocations. 5623 * 5624 * @note For legacy reasons only a directory can be a wc-root. However, this 5625 * function will also set wc_root to @c TRUE for a switched file. 5626 * 5627 * @since New in 1.7. 5628 * @deprecated Provided for backward compatibility with the 1.7 API. Consider 5629 * using svn_wc_check_root() instead. 5630 */ 5631SVN_DEPRECATED 5632svn_error_t * 5633svn_wc_is_wc_root2(svn_boolean_t *wc_root, 5634 svn_wc_context_t *wc_ctx, 5635 const char *local_abspath, 5636 apr_pool_t *scratch_pool); 5637 5638 5639/** 5640 * Similar to svn_wc_is_wc_root2(), but with an access baton and relative 5641 * path. 5642 * 5643 * @note If @a path is '', this function will always return @c TRUE. 5644 * 5645 * @deprecated Provided for backward compatibility with the 1.6 API. 5646 */ 5647SVN_DEPRECATED 5648svn_error_t * 5649svn_wc_is_wc_root(svn_boolean_t *wc_root, 5650 const char *path, 5651 svn_wc_adm_access_t *adm_access, 5652 apr_pool_t *pool); 5653 5654/** @} */ 5655 5656 5657/* Updates. */ 5658 5659/** Conditionally split @a path into an @a anchor and @a target for the 5660 * purpose of updating and committing. 5661 * 5662 * @a anchor is the directory at which the update or commit editor 5663 * should be rooted. 5664 * 5665 * @a target is the actual subject (relative to the @a anchor) of the 5666 * update/commit, or "" if the @a anchor itself is the subject. 5667 * 5668 * Allocate @a anchor and @a target in @a result_pool; @a scratch_pool 5669 * is used for temporary allocations. 5670 * 5671 * @note Even though this API uses a #svn_wc_context_t, it accepts a 5672 * (possibly) relative path and returns a (possibly) relative path in 5673 * @a *anchor. The reason being that the outputs are generally used to 5674 * open access batons, and such opening currently requires relative paths. 5675 * In the long-run, I expect this API to be removed from 1.7, due to the 5676 * remove of access batons, but for the time being, the #svn_wc_context_t 5677 * parameter allows us to avoid opening a duplicate database, just for this 5678 * function. 5679 * 5680 * @since New in 1.7. 5681 */ 5682svn_error_t * 5683svn_wc_get_actual_target2(const char **anchor, 5684 const char **target, 5685 svn_wc_context_t *wc_ctx, 5686 const char *path, 5687 apr_pool_t *result_pool, 5688 apr_pool_t *scratch_pool); 5689 5690 5691/** Similar to svn_wc_get_actual_target2(), but without the wc context, and 5692 * with a absolute path. 5693 * 5694 * @deprecated Provided for backward compatibility with the 1.6 API. 5695 */ 5696SVN_DEPRECATED 5697svn_error_t * 5698svn_wc_get_actual_target(const char *path, 5699 const char **anchor, 5700 const char **target, 5701 apr_pool_t *pool); 5702 5703 5704/** 5705 * @defgroup svn_wc_update_switch Update and switch (update-like functionality) 5706 * @{ 5707 */ 5708 5709/** 5710 * A simple callback type to wrap svn_ra_get_file(); see that 5711 * docstring for more information. 5712 * 5713 * This technique allows libsvn_client to 'wrap' svn_ra_get_file() and 5714 * pass it down into libsvn_wc functions, thus allowing the WC layer 5715 * to legally call the RA function via (blind) callback. 5716 * 5717 * @since New in 1.5 5718 * @deprecated Provided for backward compatibility with the 1.6 API. 5719 */ 5720typedef svn_error_t *(*svn_wc_get_file_t)(void *baton, 5721 const char *path, 5722 svn_revnum_t revision, 5723 svn_stream_t *stream, 5724 svn_revnum_t *fetched_rev, 5725 apr_hash_t **props, 5726 apr_pool_t *pool); 5727 5728/** 5729 * A simple callback type to wrap svn_ra_get_dir2() for avoiding issue #3569, 5730 * where a directory is updated to a revision without some of its children 5731 * recorded in the working copy. A future update won't bring these files in 5732 * because the repository assumes they are already there. 5733 * 5734 * We really only need the names of the dirents for a not-present marking, 5735 * but we also store the node-kind if we receive one. 5736 * 5737 * @a *dirents should be set to a hash mapping <tt>const char *</tt> child 5738 * names, to <tt>const svn_dirent_t *</tt> instances. 5739 * 5740 * @since New in 1.7. 5741 */ 5742typedef svn_error_t *(*svn_wc_dirents_func_t)(void *baton, 5743 apr_hash_t **dirents, 5744 const char *repos_root_url, 5745 const char *repos_relpath, 5746 apr_pool_t *result_pool, 5747 apr_pool_t *scratch_pool); 5748 5749 5750/** 5751 * DEPRECATED -- please use APIs from svn_client.h 5752 * 5753 * --- 5754 * 5755 * Set @a *editor and @a *edit_baton to an editor and baton for updating a 5756 * working copy. 5757 * 5758 * @a anchor_abspath is a local working copy directory, with a fully recursive 5759 * write lock in @a wc_ctx, which will be used as the root of our editor. 5760 * 5761 * @a target_basename is the entry in @a anchor_abspath that will actually be 5762 * updated, or the empty string if all of @a anchor_abspath should be updated. 5763 * 5764 * The editor invokes @a notify_func with @a notify_baton as the update 5765 * progresses, if @a notify_func is non-NULL. 5766 * 5767 * If @a cancel_func is non-NULL, the editor will invoke @a cancel_func with 5768 * @a cancel_baton as the update progresses to see if it should continue. 5769 * 5770 * If @a conflict_func is non-NULL, then invoke it with @a 5771 * conflict_baton whenever a conflict is encountered, giving the 5772 * callback a chance to resolve the conflict before the editor takes 5773 * more drastic measures (such as marking a file conflicted, or 5774 * bailing out of the update). 5775 * 5776 * If @a external_func is non-NULL, then invoke it with @a external_baton 5777 * whenever external changes are encountered, giving the callback a chance 5778 * to store the external information for processing. 5779 * 5780 * If @a diff3_cmd is non-NULL, then use it as the diff3 command for 5781 * any merging; otherwise, use the built-in merge code. 5782 * 5783 * @a preserved_exts is an array of filename patterns which, when 5784 * matched against the extensions of versioned files, determine for 5785 * which such files any related generated conflict files will preserve 5786 * the original file's extension as their own. If a file's extension 5787 * does not match any of the patterns in @a preserved_exts (which is 5788 * certainly the case if @a preserved_exts is @c NULL or empty), 5789 * generated conflict files will carry Subversion's custom extensions. 5790 * 5791 * @a target_revision is a pointer to a revision location which, after 5792 * successful completion of the drive of this editor, will be 5793 * populated with the revision to which the working copy was updated. 5794 * 5795 * If @a use_commit_times is TRUE, then all edited/added files will 5796 * have their working timestamp set to the last-committed-time. If 5797 * FALSE, the working files will be touched with the 'now' time. 5798 * 5799 * If @a allow_unver_obstructions is TRUE, then allow unversioned 5800 * obstructions when adding a path. 5801 * 5802 * If @a adds_as_modification is TRUE, a local addition at the same path 5803 * as an incoming addition of the same node kind results in a normal node 5804 * with a possible local modification, instead of a tree conflict. 5805 * 5806 * If @a depth is #svn_depth_infinity, update fully recursively. 5807 * Else if it is #svn_depth_immediates, update the uppermost 5808 * directory, its file entries, and the presence or absence of 5809 * subdirectories (but do not descend into the subdirectories). 5810 * Else if it is #svn_depth_files, update the uppermost directory 5811 * and its immediate file entries, but not subdirectories. 5812 * Else if it is #svn_depth_empty, update exactly the uppermost 5813 * target, and don't touch its entries. 5814 * 5815 * If @a depth_is_sticky is set and @a depth is not 5816 * #svn_depth_unknown, then in addition to updating PATHS, also set 5817 * their sticky ambient depth value to @a depth. 5818 * 5819 * If @a server_performs_filtering is TRUE, assume that the server handles 5820 * the ambient depth filtering, so this doesn't have to be handled in the 5821 * editor. 5822 * 5823 * If @a clean_checkout is TRUE, assume that we are checking out into an 5824 * empty directory, and so bypass a number of conflict checks that are 5825 * unnecessary in this case. 5826 * 5827 * If @a fetch_dirents_func is not NULL, the update editor may call this 5828 * callback, when asked to perform a depth restricted update. It will do this 5829 * before returning the editor to allow using the primary ra session for this. 5830 * 5831 * @since New in 1.7. 5832 * @deprecated Provided for backward compatibility with the 1.7 API. 5833 */ 5834SVN_DEPRECATED 5835svn_error_t * 5836svn_wc_get_update_editor4(const svn_delta_editor_t **editor, 5837 void **edit_baton, 5838 svn_revnum_t *target_revision, 5839 svn_wc_context_t *wc_ctx, 5840 const char *anchor_abspath, 5841 const char *target_basename, 5842 svn_boolean_t use_commit_times, 5843 svn_depth_t depth, 5844 svn_boolean_t depth_is_sticky, 5845 svn_boolean_t allow_unver_obstructions, 5846 svn_boolean_t adds_as_modification, 5847 svn_boolean_t server_performs_filtering, 5848 svn_boolean_t clean_checkout, 5849 const char *diff3_cmd, 5850 const apr_array_header_t *preserved_exts, 5851 svn_wc_dirents_func_t fetch_dirents_func, 5852 void *fetch_dirents_baton, 5853 svn_wc_conflict_resolver_func2_t conflict_func, 5854 void *conflict_baton, 5855 svn_wc_external_update_t external_func, 5856 void *external_baton, 5857 svn_cancel_func_t cancel_func, 5858 void *cancel_baton, 5859 svn_wc_notify_func2_t notify_func, 5860 void *notify_baton, 5861 apr_pool_t *result_pool, 5862 apr_pool_t *scratch_pool); 5863 5864/** Similar to svn_wc_get_update_editor4, but uses access batons and relative 5865 * path instead of a working copy context-abspath pair and 5866 * svn_wc_traversal_info_t instead of an externals callback. Also, 5867 * @a fetch_func and @a fetch_baton are ignored. 5868 * 5869 * If @a ti is non-NULL, record traversal info in @a ti, for use by 5870 * post-traversal accessors such as svn_wc_edited_externals(). 5871 * 5872 * All locks, both those in @a anchor and newly acquired ones, will be 5873 * released when the editor driver calls @c close_edit. 5874 * 5875 * Always sets @a adds_as_modification to TRUE, @a server_performs_filtering 5876 * and @a clean_checkout to FALSE. 5877 * 5878 * Uses a svn_wc_conflict_resolver_func_t conflict resolver instead of a 5879 * svn_wc_conflict_resolver_func2_t. 5880 * 5881 * This function assumes that @a diff3_cmd is path encoded. Later versions 5882 * assume utf-8. 5883 * 5884 * Always passes a null dirent function. 5885 * 5886 * @since New in 1.5. 5887 * @deprecated Provided for backward compatibility with the 1.6 API. 5888 */ 5889SVN_DEPRECATED 5890svn_error_t * 5891svn_wc_get_update_editor3(svn_revnum_t *target_revision, 5892 svn_wc_adm_access_t *anchor, 5893 const char *target, 5894 svn_boolean_t use_commit_times, 5895 svn_depth_t depth, 5896 svn_boolean_t depth_is_sticky, 5897 svn_boolean_t allow_unver_obstructions, 5898 svn_wc_notify_func2_t notify_func, 5899 void *notify_baton, 5900 svn_cancel_func_t cancel_func, 5901 void *cancel_baton, 5902 svn_wc_conflict_resolver_func_t conflict_func, 5903 void *conflict_baton, 5904 svn_wc_get_file_t fetch_func, 5905 void *fetch_baton, 5906 const char *diff3_cmd, 5907 const apr_array_header_t *preserved_exts, 5908 const svn_delta_editor_t **editor, 5909 void **edit_baton, 5910 svn_wc_traversal_info_t *ti, 5911 apr_pool_t *pool); 5912 5913 5914/** 5915 * Similar to svn_wc_get_update_editor3() but with the @a 5916 * allow_unver_obstructions parameter always set to FALSE, @a 5917 * conflict_func and baton set to NULL, @a fetch_func and baton set to 5918 * NULL, @a preserved_exts set to NULL, @a depth_is_sticky set to 5919 * FALSE, and @a depth set according to @a recurse: if @a recurse is 5920 * TRUE, pass #svn_depth_infinity, if FALSE, pass #svn_depth_files. 5921 * 5922 * @deprecated Provided for backward compatibility with the 1.4 API. 5923 */ 5924SVN_DEPRECATED 5925svn_error_t * 5926svn_wc_get_update_editor2(svn_revnum_t *target_revision, 5927 svn_wc_adm_access_t *anchor, 5928 const char *target, 5929 svn_boolean_t use_commit_times, 5930 svn_boolean_t recurse, 5931 svn_wc_notify_func2_t notify_func, 5932 void *notify_baton, 5933 svn_cancel_func_t cancel_func, 5934 void *cancel_baton, 5935 const char *diff3_cmd, 5936 const svn_delta_editor_t **editor, 5937 void **edit_baton, 5938 svn_wc_traversal_info_t *ti, 5939 apr_pool_t *pool); 5940 5941/** 5942 * Similar to svn_wc_get_update_editor2(), but takes an svn_wc_notify_func_t 5943 * instead. 5944 * 5945 * @deprecated Provided for backward compatibility with the 1.1 API. 5946 */ 5947SVN_DEPRECATED 5948svn_error_t * 5949svn_wc_get_update_editor(svn_revnum_t *target_revision, 5950 svn_wc_adm_access_t *anchor, 5951 const char *target, 5952 svn_boolean_t use_commit_times, 5953 svn_boolean_t recurse, 5954 svn_wc_notify_func_t notify_func, 5955 void *notify_baton, 5956 svn_cancel_func_t cancel_func, 5957 void *cancel_baton, 5958 const char *diff3_cmd, 5959 const svn_delta_editor_t **editor, 5960 void **edit_baton, 5961 svn_wc_traversal_info_t *ti, 5962 apr_pool_t *pool); 5963 5964/** 5965 * DEPRECATED -- please use APIs from svn_client.h 5966 * 5967 * --- 5968 * 5969 * A variant of svn_wc_get_update_editor4(). 5970 * 5971 * Set @a *editor and @a *edit_baton to an editor and baton for "switching" 5972 * a working copy to a new @a switch_url. (Right now, this URL must be 5973 * within the same repository that the working copy already comes 5974 * from.) @a switch_url must not be @c NULL. 5975 * 5976 * All other parameters behave as for svn_wc_get_update_editor4(). 5977 * 5978 * @since New in 1.7. 5979 * @deprecated Provided for backward compatibility with the 1.7 API. 5980 */ 5981SVN_DEPRECATED 5982svn_error_t * 5983svn_wc_get_switch_editor4(const svn_delta_editor_t **editor, 5984 void **edit_baton, 5985 svn_revnum_t *target_revision, 5986 svn_wc_context_t *wc_ctx, 5987 const char *anchor_abspath, 5988 const char *target_basename, 5989 const char *switch_url, 5990 svn_boolean_t use_commit_times, 5991 svn_depth_t depth, 5992 svn_boolean_t depth_is_sticky, 5993 svn_boolean_t allow_unver_obstructions, 5994 svn_boolean_t server_performs_filtering, 5995 const char *diff3_cmd, 5996 const apr_array_header_t *preserved_exts, 5997 svn_wc_dirents_func_t fetch_dirents_func, 5998 void *fetch_dirents_baton, 5999 svn_wc_conflict_resolver_func2_t conflict_func, 6000 void *conflict_baton, 6001 svn_wc_external_update_t external_func, 6002 void *external_baton, 6003 svn_cancel_func_t cancel_func, 6004 void *cancel_baton, 6005 svn_wc_notify_func2_t notify_func, 6006 void *notify_baton, 6007 apr_pool_t *result_pool, 6008 apr_pool_t *scratch_pool); 6009 6010/** Similar to svn_wc_get_switch_editor4, but uses access batons and relative 6011 * path instead of a working copy context and svn_wc_traversal_info_t instead 6012 * of an externals callback. 6013 * 6014 * If @a ti is non-NULL, record traversal info in @a ti, for use by 6015 * post-traversal accessors such as svn_wc_edited_externals(). 6016 * 6017 * All locks, both those in @a anchor and newly acquired ones, will be 6018 * released when the editor driver calls @c close_edit. 6019 * 6020 * Always sets @a server_performs_filtering to FALSE. 6021 * 6022 * Uses a svn_wc_conflict_resolver_func_t conflict resolver instead of a 6023 * svn_wc_conflict_resolver_func2_t. 6024 * 6025 * This function assumes that @a diff3_cmd is path encoded. Later versions 6026 * assume utf-8. 6027 * 6028 * @since New in 1.5. 6029 * @deprecated Provided for backward compatibility with the 1.6 API. 6030 */ 6031SVN_DEPRECATED 6032svn_error_t * 6033svn_wc_get_switch_editor3(svn_revnum_t *target_revision, 6034 svn_wc_adm_access_t *anchor, 6035 const char *target, 6036 const char *switch_url, 6037 svn_boolean_t use_commit_times, 6038 svn_depth_t depth, 6039 svn_boolean_t depth_is_sticky, 6040 svn_boolean_t allow_unver_obstructions, 6041 svn_wc_notify_func2_t notify_func, 6042 void *notify_baton, 6043 svn_cancel_func_t cancel_func, 6044 void *cancel_baton, 6045 svn_wc_conflict_resolver_func_t conflict_func, 6046 void *conflict_baton, 6047 const char *diff3_cmd, 6048 const apr_array_header_t *preserved_exts, 6049 const svn_delta_editor_t **editor, 6050 void **edit_baton, 6051 svn_wc_traversal_info_t *ti, 6052 apr_pool_t *pool); 6053 6054/** 6055 * Similar to svn_wc_get_switch_editor3() but with the 6056 * @a allow_unver_obstructions parameter always set to FALSE, 6057 * @a preserved_exts set to NULL, @a conflict_func and baton set to NULL, 6058 * @a depth_is_sticky set to FALSE, and @a depth set according to @a 6059 * recurse: if @a recurse is TRUE, pass #svn_depth_infinity, if 6060 * FALSE, pass #svn_depth_files. 6061 * 6062 * @deprecated Provided for backward compatibility with the 1.4 API. 6063 */ 6064SVN_DEPRECATED 6065svn_error_t * 6066svn_wc_get_switch_editor2(svn_revnum_t *target_revision, 6067 svn_wc_adm_access_t *anchor, 6068 const char *target, 6069 const char *switch_url, 6070 svn_boolean_t use_commit_times, 6071 svn_boolean_t recurse, 6072 svn_wc_notify_func2_t notify_func, 6073 void *notify_baton, 6074 svn_cancel_func_t cancel_func, 6075 void *cancel_baton, 6076 const char *diff3_cmd, 6077 const svn_delta_editor_t **editor, 6078 void **edit_baton, 6079 svn_wc_traversal_info_t *ti, 6080 apr_pool_t *pool); 6081 6082/** 6083 * Similar to svn_wc_get_switch_editor2(), but takes an 6084 * #svn_wc_notify_func_t instead. 6085 * 6086 * @deprecated Provided for backward compatibility with the 1.1 API. 6087 */ 6088SVN_DEPRECATED 6089svn_error_t * 6090svn_wc_get_switch_editor(svn_revnum_t *target_revision, 6091 svn_wc_adm_access_t *anchor, 6092 const char *target, 6093 const char *switch_url, 6094 svn_boolean_t use_commit_times, 6095 svn_boolean_t recurse, 6096 svn_wc_notify_func_t notify_func, 6097 void *notify_baton, 6098 svn_cancel_func_t cancel_func, 6099 void *cancel_baton, 6100 const char *diff3_cmd, 6101 const svn_delta_editor_t **editor, 6102 void **edit_baton, 6103 svn_wc_traversal_info_t *ti, 6104 apr_pool_t *pool); 6105 6106/** @} */ 6107 6108 6109/** 6110 * @defgroup svn_wc_properties Properties 6111 * @{ 6112 */ 6113 6114/** Set @a *props to a hash table mapping <tt>char *</tt> names onto 6115 * <tt>svn_string_t *</tt> values for all the regular properties of 6116 * @a local_abspath. Allocate the table, names, and values in 6117 * @a result_pool. If the node has no properties, then an empty hash 6118 * is returned. Use @a wc_ctx to access the working copy, and @a 6119 * scratch_pool for temporary allocations. 6120 * 6121 * If the node does not exist, #SVN_ERR_WC_PATH_NOT_FOUND is returned. 6122 * 6123 * @since New in 1.7. 6124 */ 6125svn_error_t * 6126svn_wc_prop_list2(apr_hash_t **props, 6127 svn_wc_context_t *wc_ctx, 6128 const char *local_abspath, 6129 apr_pool_t *result_pool, 6130 apr_pool_t *scratch_pool); 6131 6132/** Similar to svn_wc_prop_list2() but with a #svn_wc_adm_access_t / 6133 * relative path parameter pair. 6134 * 6135 * @deprecated Provided for backwards compatibility with the 1.6 API. 6136 */ 6137SVN_DEPRECATED 6138svn_error_t * 6139svn_wc_prop_list(apr_hash_t **props, 6140 const char *path, 6141 svn_wc_adm_access_t *adm_access, 6142 apr_pool_t *pool); 6143 6144 6145/** Return the set of "pristine" properties for @a local_abspath. 6146 * 6147 * There are node states where properties do not make sense. For these 6148 * cases, NULL will be returned in @a *props. Otherwise, a hash table 6149 * will always be returned (but may be empty, indicating no properties). 6150 * 6151 * If the node is locally-added, then @a *props will be set to NULL since 6152 * pristine properties are undefined. Note: if this addition is replacing a 6153 * previously-deleted node, then the replaced node's properties are not 6154 * available until the addition is reverted. 6155 * 6156 * If the node has been copied (from another node in the repository), then 6157 * the pristine properties will correspond to those original properties. 6158 * 6159 * If the node is locally-deleted, these properties will correspond to 6160 * the BASE node's properties, as checked-out from the repository. Note: if 6161 * this deletion is a child of a copy, then the pristine properties will 6162 * correspond to that copy's properties, not any potential BASE node. The 6163 * BASE node's properties will not be accessible until the copy is reverted. 6164 * 6165 * Nodes that are incomplete, excluded, absent, or not present at the 6166 * node's revision will return NULL in @a props. 6167 * 6168 * If the node is not versioned, SVN_ERR_WC_PATH_NOT_FOUND will be returned. 6169 * 6170 * @a props will be allocated in @a result_pool, and all temporary 6171 * allocations will be performed in @a scratch_pool. 6172 * 6173 * @since New in 1.7. 6174 */ 6175svn_error_t * 6176svn_wc_get_pristine_props(apr_hash_t **props, 6177 svn_wc_context_t *wc_ctx, 6178 const char *local_abspath, 6179 apr_pool_t *result_pool, 6180 apr_pool_t *scratch_pool); 6181 6182 6183/** Set @a *value to the value of property @a name for @a local_abspath, 6184 * allocating @a *value in @a result_pool. If no such prop, set @a *value 6185 * to @c NULL. @a name may be a regular or wc property; if it is an 6186 * entry property, return the error #SVN_ERR_BAD_PROP_KIND. @a wc_ctx 6187 * is used to access the working copy. 6188 * 6189 * If @a local_abspath is not a versioned path, return 6190 * #SVN_ERR_WC_PATH_NOT_FOUND 6191 * 6192 * @since New in 1.7. 6193 */ 6194svn_error_t * 6195svn_wc_prop_get2(const svn_string_t **value, 6196 svn_wc_context_t *wc_ctx, 6197 const char *local_abspath, 6198 const char *name, 6199 apr_pool_t *result_pool, 6200 apr_pool_t *scratch_pool); 6201 6202/** Similar to svn_wc_prop_get2(), but with a #svn_wc_adm_access_t / 6203 * relative path parameter pair. 6204 * 6205 * When @a path is not versioned, set @a *value to NULL. 6206 * 6207 * @deprecated Provided for backwards compatibility with the 1.6 API. 6208 */ 6209SVN_DEPRECATED 6210svn_error_t * 6211svn_wc_prop_get(const svn_string_t **value, 6212 const char *name, 6213 const char *path, 6214 svn_wc_adm_access_t *adm_access, 6215 apr_pool_t *pool); 6216 6217/** 6218 * Set property @a name to @a value for @a local_abspath, or if @a value is 6219 * NULL, remove property @a name from @a local_abspath. Use @a wc_ctx to 6220 * access @a local_abspath. 6221 * 6222 * @a name may be a regular property or a "wc property". If @a name is 6223 * an "entry property", return the error #SVN_ERR_BAD_PROP_KIND (even if 6224 * @a skip_checks is TRUE). 6225 * 6226 * If @a name is a "wc property", then just update the WC DAV cache for 6227 * @a local_abspath with @a name and @a value. In this case, @a depth 6228 * must be #svn_depth_empty. 6229 * 6230 * The rest of this description applies when @a name is a regular property. 6231 * 6232 * If @a name is a name in the reserved "svn:" name space, and @a value is 6233 * non-null, then canonicalize the property value and check the property 6234 * name and value as documented for svn_wc_canonicalize_svn_prop(). 6235 * @a skip_checks controls the level of checking as documented there. 6236 * 6237 * Return an error if the canonicalization or the check fails. 6238 * The error will be either #SVN_ERR_ILLEGAL_TARGET (if the 6239 * property is not appropriate for @a path), or 6240 * #SVN_ERR_BAD_MIME_TYPE (if @a name is "svn:mime-type", but @a value 6241 * is not a valid mime-type). 6242 * ### That is not currently right -- several other errors can be raised. 6243 * 6244 * @a depth follows the usual semantics for depth. 6245 * 6246 * @a changelist_filter is an array of <tt>const char *</tt> changelist 6247 * names, used as a restrictive filter on items whose properties are 6248 * set; that is, don't set properties on any item unless it's a member 6249 * of one of those changelists. If @a changelist_filter is empty (or 6250 * altogether @c NULL), no changelist filtering occurs. 6251 * 6252 * If @a cancel_func is non-NULL, then it will be invoked (with the 6253 * @a cancel_baton value passed) during the processing of the property 6254 * set (i.e. when @a depth indicates some amount of recursion). 6255 * 6256 * For each file or directory operated on, @a notify_func will be called 6257 * with its path and the @a notify_baton. @a notify_func may be @c NULL 6258 * if you are not interested in this information. 6259 * 6260 * Use @a scratch_pool for temporary allocation. 6261 * 6262 * @note If the caller is setting both svn:mime-type and svn:eol-style in 6263 * separate calls, and @a skip_checks is false, there is an ordering 6264 * dependency between them, as the validity check for svn:eol-style makes 6265 * use of the current value of svn:mime-type. 6266 * 6267 * ### The error code on validity check failure should be specified, and 6268 * should be a single code or a very small set of possibilities. 6269 * 6270 * @since New in 1.7. 6271 */ 6272svn_error_t * 6273svn_wc_prop_set4(svn_wc_context_t *wc_ctx, 6274 const char *local_abspath, 6275 const char *name, 6276 const svn_string_t *value, 6277 svn_depth_t depth, 6278 svn_boolean_t skip_checks, 6279 const apr_array_header_t *changelist_filter, 6280 svn_cancel_func_t cancel_func, 6281 void *cancel_baton, 6282 svn_wc_notify_func2_t notify_func, 6283 void *notify_baton, 6284 apr_pool_t *scratch_pool); 6285 6286/** Similar to svn_wc_prop_set4(), but with a #svn_wc_adm_access_t / 6287 * relative path parameter pair, no @a depth parameter, no changelist 6288 * filtering (for the depth-based property setting), and no cancellation. 6289 * 6290 * @since New in 1.6. 6291 * @deprecated Provided for backwards compatibility with the 1.6 API. 6292 */ 6293SVN_DEPRECATED 6294svn_error_t * 6295svn_wc_prop_set3(const char *name, 6296 const svn_string_t *value, 6297 const char *path, 6298 svn_wc_adm_access_t *adm_access, 6299 svn_boolean_t skip_checks, 6300 svn_wc_notify_func2_t notify_func, 6301 void *notify_baton, 6302 apr_pool_t *pool); 6303 6304 6305/** 6306 * Like svn_wc_prop_set3(), but without the notification callbacks. 6307 * 6308 * @since New in 1.2. 6309 * @deprecated Provided for backwards compatibility with the 1.5 API. 6310 */ 6311SVN_DEPRECATED 6312svn_error_t * 6313svn_wc_prop_set2(const char *name, 6314 const svn_string_t *value, 6315 const char *path, 6316 svn_wc_adm_access_t *adm_access, 6317 svn_boolean_t skip_checks, 6318 apr_pool_t *pool); 6319 6320 6321/** 6322 * Like svn_wc_prop_set2(), but with @a skip_checks always FALSE. 6323 * 6324 * @deprecated Provided for backward compatibility with the 1.1 API. 6325 */ 6326SVN_DEPRECATED 6327svn_error_t * 6328svn_wc_prop_set(const char *name, 6329 const svn_string_t *value, 6330 const char *path, 6331 svn_wc_adm_access_t *adm_access, 6332 apr_pool_t *pool); 6333 6334 6335/** Return TRUE iff @a name is a 'normal' property name. 'Normal' is 6336 * defined as a user-visible and user-tweakable property that shows up 6337 * when you fetch a proplist. 6338 * 6339 * The function currently parses the namespace like so: 6340 * 6341 * - 'svn:wc:' ==> a wcprop, stored/accessed separately via different API. 6342 * 6343 * - 'svn:entry:' ==> an "entry" prop, shunted into the 'entries' file. 6344 * 6345 * If these patterns aren't found, then the property is assumed to be 6346 * Normal. 6347 */ 6348svn_boolean_t 6349svn_wc_is_normal_prop(const char *name); 6350 6351 6352 6353/** Return TRUE iff @a name is a 'wc' property name. */ 6354svn_boolean_t 6355svn_wc_is_wc_prop(const char *name); 6356 6357/** Return TRUE iff @a name is a 'entry' property name. */ 6358svn_boolean_t 6359svn_wc_is_entry_prop(const char *name); 6360 6361/** Callback type used by #svn_wc_canonicalize_svn_prop. 6362 * 6363 * If @a mime_type is non-null, it sets @a *mime_type to the value of 6364 * #SVN_PROP_MIME_TYPE for the path passed to 6365 * #svn_wc_canonicalize_svn_prop (allocated from @a pool). If @a 6366 * stream is non-null, it writes the contents of the file to @a 6367 * stream. 6368 * 6369 * (Currently, this is used if you are attempting to set the 6370 * #SVN_PROP_EOL_STYLE property, to make sure that the value matches 6371 * the mime type and contents.) 6372 * 6373 * @since New in 1.5. 6374 */ 6375typedef svn_error_t *(*svn_wc_canonicalize_svn_prop_get_file_t)( 6376 const svn_string_t **mime_type, 6377 svn_stream_t *stream, 6378 void *baton, 6379 apr_pool_t *pool); 6380 6381 6382/** Canonicalize the value of an svn:* property @a propname with 6383 * value @a propval. 6384 * 6385 * If the property is not appropriate for a node of kind @a kind, or 6386 * is otherwise invalid, throw an error. Otherwise, set @a *propval_p 6387 * to a canonicalized version of the property value. 6388 * 6389 * The exact set of canonicalizations and checks may vary across different 6390 * versions of this API. Currently: 6391 * 6392 * - svn:executable 6393 * - svn:needs-lock 6394 * - svn:special 6395 * - set the value to '*' 6396 * 6397 * - svn:keywords 6398 * - strip leading and trailing white space 6399 * 6400 * - svn:ignore 6401 * - svn:global-ignores 6402 * - svn:auto-props 6403 * - add a final a newline character if missing 6404 * 6405 * - svn:externals 6406 * - add a final a newline character if missing 6407 * - check for valid syntax 6408 * - check for no duplicate entries 6409 * 6410 * - svn:mergeinfo 6411 * - canonicalize 6412 * - check for validity 6413 * 6414 * Also, unless @a skip_some_checks is TRUE: 6415 * 6416 * - svn:eol-style 6417 * - strip leading and trailing white space 6418 * - check value is recognized 6419 * - check file content has a self-consistent EOL style 6420 * (but not necessarily that it matches @a propval) 6421 * 6422 * - svn:mime-type 6423 * - strip white space 6424 * - check for reasonable syntax 6425 * 6426 * The EOL-style check (if not skipped) requires access to the contents and 6427 * MIME type of the target if it is a file. It will call @a prop_getter with 6428 * @a getter_baton. The callback must set the MIME type and/or write the 6429 * contents of the file to the given stream. If @a skip_some_checks is true, 6430 * then @a prop_getter is not used and may be NULL. 6431 * 6432 * @a path should be the path of the file in question; it is only used 6433 * for error messages. 6434 * 6435 * ### The error code on validity check failure should be specified, and 6436 * should be a single code or a very small set of possibilities. 6437 * 6438 * ### This is not actually related to the WC, but it does need to call 6439 * ### svn_wc_parse_externals_description3. 6440 * 6441 * @since New in 1.5. 6442 */ 6443svn_error_t * 6444svn_wc_canonicalize_svn_prop(const svn_string_t **propval_p, 6445 const char *propname, 6446 const svn_string_t *propval, 6447 const char *path, 6448 svn_node_kind_t kind, 6449 svn_boolean_t skip_some_checks, 6450 svn_wc_canonicalize_svn_prop_get_file_t prop_getter, 6451 void *getter_baton, 6452 apr_pool_t *pool); 6453 6454/** @} */ 6455 6456 6457/** 6458 * @defgroup svn_wc_diffs Diffs 6459 * @{ 6460 */ 6461 6462/** 6463 * DEPRECATED -- please use APIs from svn_client.h 6464 * 6465 * --- 6466 * 6467 * Return an @a editor/@a edit_baton for diffing a working copy against the 6468 * repository. The editor is allocated in @a result_pool; temporary 6469 * calculations are performed in @a scratch_pool. 6470 * 6471 * This editor supports diffing either the actual files and properties in the 6472 * working copy (when @a use_text_base is #FALSE), or the current pristine 6473 * information (when @a use_text_base is #TRUE) against the editor driver. 6474 * 6475 * @a anchor_abspath/@a target represent the base of the hierarchy to be 6476 * compared. The diff callback paths will be relative to this path. 6477 * 6478 * Diffs will be reported as valid relpaths, with @a anchor_abspath being 6479 * the root (""). 6480 * 6481 * @a callbacks/@a callback_baton is the callback table to use. 6482 * 6483 * If @a depth is #svn_depth_empty, just diff exactly @a target or 6484 * @a anchor_path if @a target is empty. If #svn_depth_files then do the same 6485 * and for top-level file entries as well (if any). If 6486 * #svn_depth_immediates, do the same as #svn_depth_files but also diff 6487 * top-level subdirectories at #svn_depth_empty. If #svn_depth_infinity, 6488 * then diff fully recursively. 6489 * 6490 * @a ignore_ancestry determines whether paths that have discontinuous node 6491 * ancestry are treated as delete/add or as simple modifications. If 6492 * @a ignore_ancestry is @c FALSE, then any discontinuous node ancestry will 6493 * result in the diff given as a full delete followed by an add. 6494 * 6495 * @a show_copies_as_adds determines whether paths added with history will 6496 * appear as a diff against their copy source, or whether such paths will 6497 * appear as if they were newly added in their entirety. 6498 * @a show_copies_as_adds implies not @a ignore_ancestry. 6499 * 6500 * If @a use_git_diff_format is TRUE, copied paths will be treated as added 6501 * if they weren't modified after being copied. This allows the callbacks 6502 * to generate appropriate --git diff headers for such files. 6503 * @a use_git_diff_format implies @a show_copies_as_adds, and as such implies 6504 * not @a ignore_ancestry. 6505 * 6506 * Normally, the difference from repository->working_copy is shown. 6507 * If @a reverse_order is TRUE, then show working_copy->repository diffs. 6508 * 6509 * If @a cancel_func is non-NULL, it will be used along with @a cancel_baton 6510 * to periodically check if the client has canceled the operation. 6511 * 6512 * @a changelist_filter is an array of <tt>const char *</tt> changelist 6513 * names, used as a restrictive filter on items whose differences are 6514 * reported; that is, don't generate diffs about any item unless 6515 * it's a member of one of those changelists. If @a changelist_filter is 6516 * empty (or altogether @c NULL), no changelist filtering occurs. 6517 * 6518 * If @a server_performs_filtering is TRUE, assume that the server handles 6519 * the ambient depth filtering, so this doesn't have to be handled in the 6520 * editor. 6521 * 6522 * @since New in 1.7. 6523 * @deprecated Provided for backward compatibility with the 1.7 API. 6524 */ 6525SVN_DEPRECATED 6526svn_error_t * 6527svn_wc_get_diff_editor6(const svn_delta_editor_t **editor, 6528 void **edit_baton, 6529 svn_wc_context_t *wc_ctx, 6530 const char *anchor_abspath, 6531 const char *target, 6532 svn_depth_t depth, 6533 svn_boolean_t ignore_ancestry, 6534 svn_boolean_t show_copies_as_adds, 6535 svn_boolean_t use_git_diff_format, 6536 svn_boolean_t use_text_base, 6537 svn_boolean_t reverse_order, 6538 svn_boolean_t server_performs_filtering, 6539 const apr_array_header_t *changelist_filter, 6540 const svn_wc_diff_callbacks4_t *callbacks, 6541 void *callback_baton, 6542 svn_cancel_func_t cancel_func, 6543 void *cancel_baton, 6544 apr_pool_t *result_pool, 6545 apr_pool_t *scratch_pool); 6546 6547/** 6548 * Similar to svn_wc_get_diff_editor6(), but with an access baton and relative 6549 * path. @a server_performs_filtering always true and with a 6550 * #svn_wc_diff_callbacks3_t instead of #svn_wc_diff_callbacks4_t, 6551 * @a show_copies_as_adds, and @a use_git_diff_format set to @c FALSE. 6552 * 6553 * Diffs will be reported as below the relative path stored in @a anchor. 6554 * 6555 * @since New in 1.6. 6556 * 6557 * @deprecated Provided for backward compatibility with the 1.6 API. 6558 */ 6559SVN_DEPRECATED 6560svn_error_t * 6561svn_wc_get_diff_editor5(svn_wc_adm_access_t *anchor, 6562 const char *target, 6563 const svn_wc_diff_callbacks3_t *callbacks, 6564 void *callback_baton, 6565 svn_depth_t depth, 6566 svn_boolean_t ignore_ancestry, 6567 svn_boolean_t use_text_base, 6568 svn_boolean_t reverse_order, 6569 svn_cancel_func_t cancel_func, 6570 void *cancel_baton, 6571 const apr_array_header_t *changelist_filter, 6572 const svn_delta_editor_t **editor, 6573 void **edit_baton, 6574 apr_pool_t *pool); 6575 6576/** 6577 * Similar to svn_wc_get_diff_editor5(), but with an 6578 * #svn_wc_diff_callbacks2_t instead of #svn_wc_diff_callbacks3_t. 6579 * 6580 * @deprecated Provided for backward compatibility with the 1.5 API. 6581 */ 6582SVN_DEPRECATED 6583svn_error_t * 6584svn_wc_get_diff_editor4(svn_wc_adm_access_t *anchor, 6585 const char *target, 6586 const svn_wc_diff_callbacks2_t *callbacks, 6587 void *callback_baton, 6588 svn_depth_t depth, 6589 svn_boolean_t ignore_ancestry, 6590 svn_boolean_t use_text_base, 6591 svn_boolean_t reverse_order, 6592 svn_cancel_func_t cancel_func, 6593 void *cancel_baton, 6594 const apr_array_header_t *changelist_filter, 6595 const svn_delta_editor_t **editor, 6596 void **edit_baton, 6597 apr_pool_t *pool); 6598 6599/** 6600 * Similar to svn_wc_get_diff_editor4(), but with @a changelist_filter 6601 * passed as @c NULL, and @a depth set to #svn_depth_infinity if @a 6602 * recurse is TRUE, or #svn_depth_files if @a recurse is FALSE. 6603 * 6604 * @deprecated Provided for backward compatibility with the 1.4 API. 6605 6606 * @since New in 1.2. 6607 */ 6608SVN_DEPRECATED 6609svn_error_t * 6610svn_wc_get_diff_editor3(svn_wc_adm_access_t *anchor, 6611 const char *target, 6612 const svn_wc_diff_callbacks2_t *callbacks, 6613 void *callback_baton, 6614 svn_boolean_t recurse, 6615 svn_boolean_t ignore_ancestry, 6616 svn_boolean_t use_text_base, 6617 svn_boolean_t reverse_order, 6618 svn_cancel_func_t cancel_func, 6619 void *cancel_baton, 6620 const svn_delta_editor_t **editor, 6621 void **edit_baton, 6622 apr_pool_t *pool); 6623 6624 6625/** 6626 * Similar to svn_wc_get_diff_editor3(), but with an 6627 * #svn_wc_diff_callbacks_t instead of #svn_wc_diff_callbacks2_t. 6628 * 6629 * @deprecated Provided for backward compatibility with the 1.1 API. 6630 */ 6631SVN_DEPRECATED 6632svn_error_t * 6633svn_wc_get_diff_editor2(svn_wc_adm_access_t *anchor, 6634 const char *target, 6635 const svn_wc_diff_callbacks_t *callbacks, 6636 void *callback_baton, 6637 svn_boolean_t recurse, 6638 svn_boolean_t ignore_ancestry, 6639 svn_boolean_t use_text_base, 6640 svn_boolean_t reverse_order, 6641 svn_cancel_func_t cancel_func, 6642 void *cancel_baton, 6643 const svn_delta_editor_t **editor, 6644 void **edit_baton, 6645 apr_pool_t *pool); 6646 6647 6648/** 6649 * Similar to svn_wc_get_diff_editor2(), but with @a ignore_ancestry 6650 * always set to @c FALSE. 6651 * 6652 * @deprecated Provided for backward compatibility with the 1.0 API. 6653 */ 6654SVN_DEPRECATED 6655svn_error_t * 6656svn_wc_get_diff_editor(svn_wc_adm_access_t *anchor, 6657 const char *target, 6658 const svn_wc_diff_callbacks_t *callbacks, 6659 void *callback_baton, 6660 svn_boolean_t recurse, 6661 svn_boolean_t use_text_base, 6662 svn_boolean_t reverse_order, 6663 svn_cancel_func_t cancel_func, 6664 void *cancel_baton, 6665 const svn_delta_editor_t **editor, 6666 void **edit_baton, 6667 apr_pool_t *pool); 6668 6669 6670/** 6671 * Compare working copy against the text-base. 6672 * 6673 * @a target_abspath represents the base of the hierarchy to be compared. 6674 * 6675 * @a callbacks/@a callback_baton is the callback table to use when two 6676 * files are to be compared. 6677 * 6678 * If @a depth is #svn_depth_empty, just diff exactly @a target_path. 6679 * If #svn_depth_files then do the same 6680 * and for top-level file entries as well (if any). If 6681 * #svn_depth_immediates, do the same as #svn_depth_files but also diff 6682 * top-level subdirectories at #svn_depth_empty. If #svn_depth_infinity, 6683 * then diff fully recursively. 6684 * 6685 * @a ignore_ancestry determines whether paths that have discontinuous node 6686 * ancestry are treated as delete/add or as simple modifications. If 6687 * @a ignore_ancestry is @c FALSE, then any discontinuous node ancestry will 6688 * result in the diff given as a full delete followed by an add. 6689 * 6690 * @a show_copies_as_adds determines whether paths added with history will 6691 * appear as a diff against their copy source, or whether such paths will 6692 * appear as if they were newly added in their entirety. 6693 * 6694 * If @a use_git_diff_format is TRUE, copied paths will be treated as added 6695 * if they weren't modified after being copied. This allows the callbacks 6696 * to generate appropriate --git diff headers for such files. 6697 * 6698 * @a changelist_filter is an array of <tt>const char *</tt> changelist 6699 * names, used as a restrictive filter on items whose differences are 6700 * reported; that is, don't generate diffs about any item unless 6701 * it's a member of one of those changelists. If @a changelist_filter is 6702 * empty (or altogether @c NULL), no changelist filtering occurs. 6703 * 6704 * If @a cancel_func is non-NULL, invoke it with @a cancel_baton at various 6705 * points during the operation. If it returns an error (typically 6706 * #SVN_ERR_CANCELLED), return that error immediately. 6707 * 6708 * @since New in 1.7. 6709 */ 6710svn_error_t * 6711svn_wc_diff6(svn_wc_context_t *wc_ctx, 6712 const char *target_abspath, 6713 const svn_wc_diff_callbacks4_t *callbacks, 6714 void *callback_baton, 6715 svn_depth_t depth, 6716 svn_boolean_t ignore_ancestry, 6717 svn_boolean_t show_copies_as_adds, 6718 svn_boolean_t use_git_diff_format, 6719 const apr_array_header_t *changelist_filter, 6720 svn_cancel_func_t cancel_func, 6721 void *cancel_baton, 6722 apr_pool_t *scratch_pool); 6723 6724/** 6725 * Similar to svn_wc_diff6(), but with a #svn_wc_diff_callbacks3_t argument 6726 * instead of #svn_wc_diff_callbacks4_t, @a show_copies_as_adds, 6727 * and @a use_git_diff_format set to * @c FALSE. 6728 * It also doesn't allow specifying a cancel function. 6729 * 6730 * @since New in 1.6. 6731 * @deprecated Provided for backward compatibility with the 1.6 API. 6732 */ 6733SVN_DEPRECATED 6734svn_error_t * 6735svn_wc_diff5(svn_wc_adm_access_t *anchor, 6736 const char *target, 6737 const svn_wc_diff_callbacks3_t *callbacks, 6738 void *callback_baton, 6739 svn_depth_t depth, 6740 svn_boolean_t ignore_ancestry, 6741 const apr_array_header_t *changelist_filter, 6742 apr_pool_t *pool); 6743 6744/** 6745 * Similar to svn_wc_diff5(), but with a #svn_wc_diff_callbacks2_t argument 6746 * instead of #svn_wc_diff_callbacks3_t. 6747 * 6748 * @since New in 1.5. 6749 * @deprecated Provided for backward compatibility with the 1.5 API. 6750 */ 6751SVN_DEPRECATED 6752svn_error_t * 6753svn_wc_diff4(svn_wc_adm_access_t *anchor, 6754 const char *target, 6755 const svn_wc_diff_callbacks2_t *callbacks, 6756 void *callback_baton, 6757 svn_depth_t depth, 6758 svn_boolean_t ignore_ancestry, 6759 const apr_array_header_t *changelist_filter, 6760 apr_pool_t *pool); 6761 6762/** 6763 * Similar to svn_wc_diff4(), but with @a changelist_filter passed @c NULL, 6764 * and @a depth set to #svn_depth_infinity if @a recurse is TRUE, or 6765 * #svn_depth_files if @a recurse is FALSE. 6766 * 6767 * @since New in 1.2. 6768 * @deprecated Provided for backward compatibility with the 1.4 API. 6769 */ 6770SVN_DEPRECATED 6771svn_error_t * 6772svn_wc_diff3(svn_wc_adm_access_t *anchor, 6773 const char *target, 6774 const svn_wc_diff_callbacks2_t *callbacks, 6775 void *callback_baton, 6776 svn_boolean_t recurse, 6777 svn_boolean_t ignore_ancestry, 6778 apr_pool_t *pool); 6779 6780/** 6781 * Similar to svn_wc_diff3(), but with a #svn_wc_diff_callbacks_t argument 6782 * instead of #svn_wc_diff_callbacks2_t. 6783 * 6784 * @since New in 1.1. 6785 * @deprecated Provided for backward compatibility with the 1.1 API. 6786 */ 6787SVN_DEPRECATED 6788svn_error_t * 6789svn_wc_diff2(svn_wc_adm_access_t *anchor, 6790 const char *target, 6791 const svn_wc_diff_callbacks_t *callbacks, 6792 void *callback_baton, 6793 svn_boolean_t recurse, 6794 svn_boolean_t ignore_ancestry, 6795 apr_pool_t *pool); 6796 6797/** 6798 * Similar to svn_wc_diff2(), but with @a ignore_ancestry always set 6799 * to @c FALSE. 6800 * 6801 * @deprecated Provided for backward compatibility with the 1.0 API. 6802 */ 6803SVN_DEPRECATED 6804svn_error_t * 6805svn_wc_diff(svn_wc_adm_access_t *anchor, 6806 const char *target, 6807 const svn_wc_diff_callbacks_t *callbacks, 6808 void *callback_baton, 6809 svn_boolean_t recurse, 6810 apr_pool_t *pool); 6811 6812 6813/** Given a @a local_abspath to a file or directory under version control, 6814 * discover any local changes made to properties and/or the set of 'pristine' 6815 * properties. @a wc_ctx will be used to access the working copy. 6816 * 6817 * If @a propchanges is non-@c NULL, return these changes as an array of 6818 * #svn_prop_t structures stored in @a *propchanges. The structures and 6819 * array will be allocated in @a result_pool. If there are no local property 6820 * modifications on @a local_abspath, then set @a *propchanges will be empty. 6821 * 6822 * If @a original_props is non-@c NULL, then set @a *original_props to 6823 * hashtable (<tt>const char *name</tt> -> <tt>const svn_string_t *value</tt>) 6824 * that represents the 'pristine' property list of @a path. This hashtable is 6825 * allocated in @a result_pool. 6826 * 6827 * Use @a scratch_pool for temporary allocations. 6828 */ 6829svn_error_t * 6830svn_wc_get_prop_diffs2(apr_array_header_t **propchanges, 6831 apr_hash_t **original_props, 6832 svn_wc_context_t *wc_ctx, 6833 const char *local_abspath, 6834 apr_pool_t *result_pool, 6835 apr_pool_t *scratch_pool); 6836 6837/** Similar to svn_wc_get_prop_diffs2(), but with a #svn_wc_adm_access_t / 6838 * relative path parameter pair. 6839 * 6840 * @deprecated Provided for backwards compatibility with the 1.6 API. 6841 */ 6842SVN_DEPRECATED 6843svn_error_t * 6844svn_wc_get_prop_diffs(apr_array_header_t **propchanges, 6845 apr_hash_t **original_props, 6846 const char *path, 6847 svn_wc_adm_access_t *adm_access, 6848 apr_pool_t *pool); 6849 6850/** @} */ 6851 6852 6853/** 6854 * @defgroup svn_wc_merging Merging 6855 * @{ 6856 */ 6857 6858/** The outcome of a merge carried out (or tried as a dry-run) by 6859 * svn_wc_merge() 6860 */ 6861typedef enum svn_wc_merge_outcome_t 6862{ 6863 /** The working copy is (or would be) unchanged. The changes to be 6864 * merged were already present in the working copy 6865 */ 6866 svn_wc_merge_unchanged, 6867 6868 /** The working copy has been (or would be) changed. */ 6869 svn_wc_merge_merged, 6870 6871 /** The working copy has been (or would be) changed, but there was (or 6872 * would be) a conflict 6873 */ 6874 svn_wc_merge_conflict, 6875 6876 /** No merge was performed, probably because the target file was 6877 * either absent or not under version control. 6878 */ 6879 svn_wc_merge_no_merge 6880 6881} svn_wc_merge_outcome_t; 6882 6883/** Given absolute paths to three fulltexts, merge the differences between 6884 * @a left_abspath and @a right_abspath into @a target_abspath. 6885 * It may help to know that @a left_abspath, @a right_abspath and @a 6886 * target_abspath correspond to "OLDER", "YOURS", and "MINE", 6887 * respectively, in the diff3 documentation. 6888 * 6889 * @a wc_ctx should contain a write lock for the directory containing @a 6890 * target_abspath. 6891 * 6892 * This function assumes that @a left_abspath and @a right_abspath are 6893 * in repository-normal form (linefeeds, with keywords contracted); if 6894 * necessary, @a target_abspath is temporarily converted to this form to 6895 * receive the changes, then translated back again. 6896 * 6897 * If @a target_abspath is absent, or present but not under version 6898 * control, then set @a *merge_content_outcome to #svn_wc_merge_no_merge and 6899 * return success without merging anything. (The reasoning is that if 6900 * the file is not versioned, then it is probably unrelated to the 6901 * changes being considered, so they should not be merged into it. 6902 * Furthermore, merging into an unversioned file is a lossy operation.) 6903 * 6904 * @a dry_run determines whether the working copy is modified. When it 6905 * is @c FALSE the merge will cause @a target_abspath to be modified, when 6906 * it is @c TRUE the merge will be carried out to determine the result but 6907 * @a target_abspath will not be modified. 6908 * 6909 * If @a diff3_cmd is non-NULL, then use it as the diff3 command for 6910 * any merging; otherwise, use the built-in merge code. If @a 6911 * merge_options is non-NULL, either pass its elements to @a diff3_cmd or 6912 * parse it and use as options to the internal merge code (see 6913 * svn_diff_file_options_parse()). @a merge_options must contain 6914 * <tt>const char *</tt> elements. 6915 * 6916 * If @a merge_props_state is non-NULL, merge @a prop_diff into the 6917 * working properties before merging the text. (If @a merge_props_state 6918 * is NULL, do not merge any property changes; in this case, @a prop_diff 6919 * is only used to help determine the text merge result.) Handle any 6920 * conflicts as described for svn_wc_merge_props3(), with the parameters 6921 * @a dry_run, @a conflict_func and @a conflict_baton. Return the 6922 * outcome of the property merge in @a *merge_props_state. 6923 * 6924 * The outcome of the text merge is returned in @a *merge_content_outcome. If 6925 * there is a conflict and @a dry_run is @c FALSE, then attempt to call @a 6926 * conflict_func with @a conflict_baton (if non-NULL). If the 6927 * conflict callback cannot resolve the conflict, then: 6928 * 6929 * * Put conflict markers around the conflicting regions in 6930 * @a target_abspath, labeled with @a left_label, @a right_label, and 6931 * @a target_label. (If any of these labels are @c NULL, default 6932 * values will be used.) 6933 * 6934 * * Copy @a left_abspath, @a right_abspath, and the original @a 6935 * target_abspath to unique names in the same directory as @a 6936 * target_abspath, ending with the suffixes ".LEFT_LABEL", ".RIGHT_LABEL", 6937 * and ".TARGET_LABEL" respectively. 6938 * 6939 * * Mark @a target_abspath as "text-conflicted", and track the above 6940 * mentioned backup files as well. 6941 * 6942 * * If @a left_version and/or @a right_version are not NULL, provide 6943 * these values to the conflict handler and track these while the conflict 6944 * exists. 6945 * 6946 * Binary case: 6947 * 6948 * If @a target_abspath is a binary file, then no merging is attempted, 6949 * the merge is deemed to be a conflict. If @a dry_run is @c FALSE the 6950 * working @a target_abspath is untouched, and copies of @a left_abspath and 6951 * @a right_abspath are created next to it using @a left_label and 6952 * @a right_label. @a target_abspath is marked as "text-conflicted", and 6953 * begins tracking the two backup files and the version information. 6954 * 6955 * If @a dry_run is @c TRUE no files are changed. The outcome of the merge 6956 * is returned in @a *merge_content_outcome. 6957 * ### (and what about @a *merge_props_state?) 6958 * 6959 * ### BH: Two kinds of outcome is not how it should be. 6960 * 6961 * ### For text, we report the outcome as 'merged' if there was some 6962 * incoming change that we dealt with (even if we decided to no-op?) 6963 * but the callers then convert this outcome into a notification 6964 * of 'merged' only if there was already a local modification; 6965 * otherwise they notify it as simply 'updated'. But for props 6966 * we report a notify state of 'merged' here if there was an 6967 * incoming change regardless of the local-mod state. Inconsistent. 6968 * 6969 * Use @a scratch_pool for any temporary allocation. 6970 * 6971 * @since New in 1.8. 6972 */ 6973svn_error_t * 6974svn_wc_merge5(enum svn_wc_merge_outcome_t *merge_content_outcome, 6975 enum svn_wc_notify_state_t *merge_props_state, 6976 svn_wc_context_t *wc_ctx, 6977 const char *left_abspath, 6978 const char *right_abspath, 6979 const char *target_abspath, 6980 const char *left_label, 6981 const char *right_label, 6982 const char *target_label, 6983 const svn_wc_conflict_version_t *left_version, 6984 const svn_wc_conflict_version_t *right_version, 6985 svn_boolean_t dry_run, 6986 const char *diff3_cmd, 6987 const apr_array_header_t *merge_options, 6988 apr_hash_t *original_props, 6989 const apr_array_header_t *prop_diff, 6990 svn_wc_conflict_resolver_func2_t conflict_func, 6991 void *conflict_baton, 6992 svn_cancel_func_t cancel_func, 6993 void *cancel_baton, 6994 apr_pool_t *scratch_pool); 6995 6996/** Similar to svn_wc_merge5() but with @a merge_props_state and @a 6997 * original_props always passed as NULL. 6998 * 6999 * Unlike svn_wc_merge5(), this function doesn't merge property 7000 * changes. Callers of this function must first use 7001 * svn_wc_merge_props3() to get this functionality. 7002 * 7003 * @since New in 1.7. 7004 * @deprecated Provided for backwards compatibility with the 1.7 API. 7005 */ 7006SVN_DEPRECATED 7007svn_error_t * 7008svn_wc_merge4(enum svn_wc_merge_outcome_t *merge_outcome, 7009 svn_wc_context_t *wc_ctx, 7010 const char *left_abspath, 7011 const char *right_abspath, 7012 const char *target_abspath, 7013 const char *left_label, 7014 const char *right_label, 7015 const char *target_label, 7016 const svn_wc_conflict_version_t *left_version, 7017 const svn_wc_conflict_version_t *right_version, 7018 svn_boolean_t dry_run, 7019 const char *diff3_cmd, 7020 const apr_array_header_t *merge_options, 7021 const apr_array_header_t *prop_diff, 7022 svn_wc_conflict_resolver_func2_t conflict_func, 7023 void *conflict_baton, 7024 svn_cancel_func_t cancel_func, 7025 void *cancel_baton, 7026 apr_pool_t *scratch_pool); 7027 7028 7029/** Similar to svn_wc_merge4() but takes relative paths and an access 7030 * baton. It doesn't support a cancel function or tracking origin version 7031 * information. 7032 * 7033 * Uses a svn_wc_conflict_resolver_func_t conflict resolver instead of a 7034 * svn_wc_conflict_resolver_func2_t. 7035 * 7036 * This function assumes that @a diff3_cmd is path encoded. Later versions 7037 * assume utf-8. 7038 * 7039 * @since New in 1.5. 7040 * @deprecated Provided for backwards compatibility with the 1.6 API. 7041 */ 7042SVN_DEPRECATED 7043svn_error_t * 7044svn_wc_merge3(enum svn_wc_merge_outcome_t *merge_outcome, 7045 const char *left, 7046 const char *right, 7047 const char *merge_target, 7048 svn_wc_adm_access_t *adm_access, 7049 const char *left_label, 7050 const char *right_label, 7051 const char *target_label, 7052 svn_boolean_t dry_run, 7053 const char *diff3_cmd, 7054 const apr_array_header_t *merge_options, 7055 const apr_array_header_t *prop_diff, 7056 svn_wc_conflict_resolver_func_t conflict_func, 7057 void *conflict_baton, 7058 apr_pool_t *pool); 7059 7060 7061/** Similar to svn_wc_merge3(), but with @a prop_diff, @a 7062 * conflict_func, @a conflict_baton set to NULL. 7063 * 7064 * @deprecated Provided for backwards compatibility with the 1.4 API. 7065 */ 7066SVN_DEPRECATED 7067svn_error_t * 7068svn_wc_merge2(enum svn_wc_merge_outcome_t *merge_outcome, 7069 const char *left, 7070 const char *right, 7071 const char *merge_target, 7072 svn_wc_adm_access_t *adm_access, 7073 const char *left_label, 7074 const char *right_label, 7075 const char *target_label, 7076 svn_boolean_t dry_run, 7077 const char *diff3_cmd, 7078 const apr_array_header_t *merge_options, 7079 apr_pool_t *pool); 7080 7081 7082/** Similar to svn_wc_merge2(), but with @a merge_options set to NULL. 7083 * 7084 * @deprecated Provided for backwards compatibility with the 1.3 API. 7085 */ 7086SVN_DEPRECATED 7087svn_error_t * 7088svn_wc_merge(const char *left, 7089 const char *right, 7090 const char *merge_target, 7091 svn_wc_adm_access_t *adm_access, 7092 const char *left_label, 7093 const char *right_label, 7094 const char *target_label, 7095 svn_boolean_t dry_run, 7096 enum svn_wc_merge_outcome_t *merge_outcome, 7097 const char *diff3_cmd, 7098 apr_pool_t *pool); 7099 7100 7101/** Given a @a local_abspath under version control, merge an array of @a 7102 * propchanges into the path's existing properties. @a propchanges is 7103 * an array of #svn_prop_t objects, and @a baseprops is a hash 7104 * representing the original set of properties that @a propchanges is 7105 * working against. @a wc_ctx contains a lock for @a local_abspath. 7106 * 7107 * Only the working properties will be changed. 7108 * 7109 * If @a state is non-NULL, set @a *state to the state of the properties 7110 * after the merge. 7111 * 7112 * If a conflict is found when merging a property, and @a dry_run is 7113 * false and @a conflict_func is not null, then call @a conflict_func 7114 * with @a conflict_baton and a description of the conflict. If any 7115 * conflicts are not resolved by such callbacks, describe the unresolved 7116 * conflicts in a temporary .prej file (or append to an already-existing 7117 * .prej file) and mark the path as conflicted in the WC DB. 7118 * 7119 * If @a cancel_func is non-NULL, invoke it with @a cancel_baton at various 7120 * points during the operation. If it returns an error (typically 7121 * #SVN_ERR_CANCELLED), return that error immediately. 7122 * 7123 * If @a local_abspath is not under version control, return the error 7124 * #SVN_ERR_WC_PATH_NOT_FOUND and don't touch anyone's properties. 7125 * 7126 * If @a local_abspath has a status in which it doesn't have properties 7127 * (E.g. deleted) return the error SVN_ERR_WC_PATH_UNEXPECTED_STATUS. 7128 * 7129 * @since New in 1.7. 7130 */ 7131svn_error_t * 7132svn_wc_merge_props3(svn_wc_notify_state_t *state, 7133 svn_wc_context_t *wc_ctx, 7134 const char *local_abspath, 7135 const svn_wc_conflict_version_t *left_version, 7136 const svn_wc_conflict_version_t *right_version, 7137 apr_hash_t *baseprops, 7138 const apr_array_header_t *propchanges, 7139 svn_boolean_t dry_run, 7140 svn_wc_conflict_resolver_func2_t conflict_func, 7141 void *conflict_baton, 7142 svn_cancel_func_t cancel_func, 7143 void *cancel_baton, 7144 apr_pool_t *scratch_pool); 7145 7146 7147/** Similar to svn_wc_merge_props3, but takes an access baton and relative 7148 * path, no cancel_function, and no left and right version. 7149 * 7150 * This function has the @a base_merge parameter which (when TRUE) will 7151 * apply @a propchanges to this node's pristine set of properties. This 7152 * functionality is not supported since API version 1.7 and will give an 7153 * error if requested (unless @a dry_run is TRUE). For details see 7154 * 'notes/api-errata/1.7/wc006.txt'. 7155 * 7156 * Uses a svn_wc_conflict_resolver_func_t conflict resolver instead of a 7157 * svn_wc_conflict_resolver_func2_t. 7158 * 7159 * For compatibility reasons this function returns 7160 * #SVN_ERR_UNVERSIONED_RESOURCE, when svn_wc_merge_props3 would return either 7161 * #SVN_ERR_WC_PATH_NOT_FOUND or #SVN_ERR_WC_PATH_UNEXPECTED_STATUS. 7162 * 7163 * @since New in 1.5. The base_merge option is not supported since 1.7. 7164 * @deprecated Provided for backward compatibility with the 1.6 API. 7165 */ 7166SVN_DEPRECATED 7167svn_error_t * 7168svn_wc_merge_props2(svn_wc_notify_state_t *state, 7169 const char *path, 7170 svn_wc_adm_access_t *adm_access, 7171 apr_hash_t *baseprops, 7172 const apr_array_header_t *propchanges, 7173 svn_boolean_t base_merge, 7174 svn_boolean_t dry_run, 7175 svn_wc_conflict_resolver_func_t conflict_func, 7176 void *conflict_baton, 7177 apr_pool_t *pool); 7178 7179 7180/** 7181 * Same as svn_wc_merge_props2(), but with a @a conflict_func (and 7182 * baton) of NULL. 7183 * 7184 * @since New in 1.3. The base_merge option is not supported since 1.7. 7185 * @deprecated Provided for backward compatibility with the 1.4 API. 7186 */ 7187SVN_DEPRECATED 7188svn_error_t * 7189svn_wc_merge_props(svn_wc_notify_state_t *state, 7190 const char *path, 7191 svn_wc_adm_access_t *adm_access, 7192 apr_hash_t *baseprops, 7193 const apr_array_header_t *propchanges, 7194 svn_boolean_t base_merge, 7195 svn_boolean_t dry_run, 7196 apr_pool_t *pool); 7197 7198 7199/** 7200 * Similar to svn_wc_merge_props(), but no baseprops are given. 7201 * Instead, it's assumed that the incoming propchanges are based 7202 * against the working copy's own baseprops. While this assumption is 7203 * correct for 'svn update', it's incorrect for 'svn merge', and can 7204 * cause flawed behavior. (See issue #2035.) 7205 * 7206 * @since The base_merge option is not supported since 1.7. 7207 * @deprecated Provided for backward compatibility with the 1.2 API. 7208 * Replaced by svn_wc_merge_props(). 7209 */ 7210SVN_DEPRECATED 7211svn_error_t * 7212svn_wc_merge_prop_diffs(svn_wc_notify_state_t *state, 7213 const char *path, 7214 svn_wc_adm_access_t *adm_access, 7215 const apr_array_header_t *propchanges, 7216 svn_boolean_t base_merge, 7217 svn_boolean_t dry_run, 7218 apr_pool_t *pool); 7219 7220/** @} */ 7221 7222 7223/** Given a @a path to a wc file, return in @a *contents a readonly stream to 7224 * the pristine contents of the file that would serve as base content for the 7225 * next commit. That means: 7226 * 7227 * When there is no change in node history scheduled, i.e. when there are only 7228 * local text-mods, prop-mods or a delete, return the last checked-out or 7229 * updated-/switched-to contents of the file. 7230 * 7231 * If the file is simply added or replaced (no copy-/move-here involved), 7232 * set @a *contents to @c NULL. 7233 * 7234 * When the file has been locally copied-/moved-here, return the contents of 7235 * the copy/move source (even if the copy-/move-here replaces a locally 7236 * deleted file). 7237 * 7238 * If @a local_abspath refers to an unversioned or non-existent path, return 7239 * @c SVN_ERR_WC_PATH_NOT_FOUND. Use @a wc_ctx to access the working copy. 7240 * @a contents may not be @c NULL (unlike @a *contents). 7241 * 7242 * @since New in 1.7. */ 7243svn_error_t * 7244svn_wc_get_pristine_contents2(svn_stream_t **contents, 7245 svn_wc_context_t *wc_ctx, 7246 const char *local_abspath, 7247 apr_pool_t *result_pool, 7248 apr_pool_t *scratch_pool); 7249 7250/** Similar to svn_wc_get_pristine_contents2, but takes no working copy 7251 * context and a path that can be relative 7252 * 7253 * @since New in 1.6. 7254 * @deprecated Provided for backward compatibility with the 1.6 API. 7255 */ 7256SVN_DEPRECATED 7257svn_error_t * 7258svn_wc_get_pristine_contents(svn_stream_t **contents, 7259 const char *path, 7260 apr_pool_t *result_pool, 7261 apr_pool_t *scratch_pool); 7262 7263 7264/** Set @a *pristine_path to the path of the "normal" pristine text file for 7265 * the versioned file @a path. 7266 * 7267 * If @a path does not have a pristine text, set @a *pristine_path to a path where 7268 * nothing exists on disk (in a directory that does exist). 7269 * 7270 * @note: Before version 1.7, the behaviour in that case was to provide the 7271 * path where the pristine text *would be* if it were present. The new 7272 * behaviour is intended to provide backward compatibility for callers that 7273 * open or test the provided path immediately, and not for callers that 7274 * store the path for later use. 7275 * 7276 * @deprecated Provided for backwards compatibility with the 1.5 API. 7277 * Callers should use svn_wc_get_pristine_contents() instead. 7278 */ 7279SVN_DEPRECATED 7280svn_error_t * 7281svn_wc_get_pristine_copy_path(const char *path, 7282 const char **pristine_path, 7283 apr_pool_t *pool); 7284 7285 7286/** 7287 * Recurse from @a local_abspath, cleaning up unfinished tasks. Perform 7288 * any temporary allocations in @a scratch_pool. If @a break_locks is TRUE 7289 * Any working copy locks under @a local_abspath will be taken over and then 7290 * cleared by this function. 7291 * WARNING: If @a break_locks is TRUE there is no mechanism that will protect 7292 * locks that are still being used. 7293 * 7294 * If @a fix_recorded_timestamps is TRUE the recorded timestamps of unmodified 7295 * files will be updated, which will improve performance of future is-modified 7296 * checks. 7297 * 7298 * If @a clear_dav_cache is @c TRUE, the caching of DAV information for older 7299 * mod_dav served repositories is cleared. This clearing invalidates some 7300 * cached information used for pre-HTTPv2 repositories. 7301 * 7302 * If @a vacuum_pristines is TRUE, try to remove unreferenced pristines from 7303 * the working copy. (Will not remove anything unless the obtained lock applies 7304 * to the entire working copy) 7305 * 7306 * If @a cancel_func is non-NULL, invoke it with @a cancel_baton at various 7307 * points during the operation. If it returns an error (typically 7308 * #SVN_ERR_CANCELLED), return that error immediately. 7309 * 7310 * If @a notify_func is non-NULL, invoke it with @a notify_baton to report 7311 * the progress of the operation. 7312 * 7313 * @note In 1.9, @a notify_func does not get called at all. This may change 7314 * in later releases. 7315 * 7316 * @since New in 1.9. 7317 */ 7318svn_error_t * 7319svn_wc_cleanup4(svn_wc_context_t *wc_ctx, 7320 const char *local_abspath, 7321 svn_boolean_t break_locks, 7322 svn_boolean_t fix_recorded_timestamps, 7323 svn_boolean_t clear_dav_cache, 7324 svn_boolean_t vacuum_pristines, 7325 svn_cancel_func_t cancel_func, 7326 void *cancel_baton, 7327 svn_wc_notify_func2_t notify_func, 7328 void *notify_baton, 7329 apr_pool_t *scratch_pool); 7330 7331/** 7332 * Similar to svn_wc_cleanup4() but will always break locks, fix recorded 7333 * timestamps, clear the dav cache and vacuum pristines. This function also 7334 * doesn't support notifications. 7335 * 7336 * @since New in 1.7. 7337 * @deprecated Provided for backward compatibility with the 1.8 API. 7338 */ 7339SVN_DEPRECATED 7340svn_error_t * 7341svn_wc_cleanup3(svn_wc_context_t *wc_ctx, 7342 const char *local_abspath, 7343 svn_cancel_func_t cancel_func, 7344 void *cancel_baton, 7345 apr_pool_t *scratch_pool); 7346 7347/** 7348 * Similar to svn_wc_cleanup3() but uses relative paths and creates its own 7349 * #svn_wc_context_t. 7350 * 7351 * @since New in 1.2. 7352 * @deprecated Provided for backward compatibility with the 1.6 API. 7353 */ 7354SVN_DEPRECATED 7355svn_error_t * 7356svn_wc_cleanup2(const char *path, 7357 const char *diff3_cmd, 7358 svn_cancel_func_t cancel_func, 7359 void *cancel_baton, 7360 apr_pool_t *pool); 7361 7362/** 7363 * Similar to svn_wc_cleanup2(). @a optional_adm_access is an historic 7364 * relic and not used, it may be NULL. 7365 * 7366 * @deprecated Provided for backward compatibility with the 1.1 API. 7367 */ 7368SVN_DEPRECATED 7369svn_error_t * 7370svn_wc_cleanup(const char *path, 7371 svn_wc_adm_access_t *optional_adm_access, 7372 const char *diff3_cmd, 7373 svn_cancel_func_t cancel_func, 7374 void *cancel_baton, 7375 apr_pool_t *pool); 7376 7377/** Callback for retrieving a repository root for a url from upgrade. 7378 * 7379 * Called by svn_wc_upgrade() when no repository root and/or repository 7380 * uuid are recorded in the working copy. For normal Subversion 1.5 and 7381 * later working copies, this callback will not be used. 7382 * 7383 * @since New in 1.7. 7384 */ 7385typedef svn_error_t * (*svn_wc_upgrade_get_repos_info_t)( 7386 const char **repos_root, 7387 const char **repos_uuid, 7388 void *baton, 7389 const char *url, 7390 apr_pool_t *result_pool, 7391 apr_pool_t *scratch_pool); 7392 7393 7394/** 7395 * Upgrade the working copy at @a local_abspath to the latest metadata 7396 * storage format. @a local_abspath should be an absolute path to the 7397 * root of the working copy. 7398 * 7399 * If @a cancel_func is non-NULL, invoke it with @a cancel_baton at 7400 * various points during the operation. If it returns an error 7401 * (typically #SVN_ERR_CANCELLED), return that error immediately. 7402 * 7403 * For each directory converted, @a notify_func will be called with 7404 * in @a notify_baton action #svn_wc_notify_upgraded_path and as path 7405 * the path of the upgraded directory. @a notify_func may be @c NULL 7406 * if this notification is not needed. 7407 * 7408 * If the old working copy doesn't contain a repository root and/or 7409 * repository uuid, @a repos_info_func (if non-NULL) will be called 7410 * with @a repos_info_baton to provide the missing information. 7411 * 7412 * @since New in 1.7. 7413 */ 7414svn_error_t * 7415svn_wc_upgrade(svn_wc_context_t *wc_ctx, 7416 const char *local_abspath, 7417 svn_wc_upgrade_get_repos_info_t repos_info_func, 7418 void *repos_info_baton, 7419 svn_cancel_func_t cancel_func, 7420 void *cancel_baton, 7421 svn_wc_notify_func2_t notify_func, 7422 void *notify_baton, 7423 apr_pool_t *scratch_pool); 7424 7425 7426/** Relocation validation callback typedef. 7427 * 7428 * Called for each relocated file/directory. @a uuid, if non-NULL, contains 7429 * the expected repository UUID, @a url contains the tentative URL. 7430 * 7431 * @a baton is a closure object; it should be provided by the 7432 * implementation, and passed by the caller. 7433 * 7434 * If @a root_url is passed, then the implementation should make sure that 7435 * @a url is the repository root. 7436 * @a pool may be used for temporary allocations. 7437 * 7438 * @since New in 1.5. 7439 */ 7440typedef svn_error_t *(*svn_wc_relocation_validator3_t)(void *baton, 7441 const char *uuid, 7442 const char *url, 7443 const char *root_url, 7444 apr_pool_t *pool); 7445 7446/** Similar to #svn_wc_relocation_validator3_t, but with 7447 * the @a root argument. 7448 * 7449 * If @a root is TRUE, then the implementation should make sure that @a url 7450 * is the repository root. Else, it can be a URL inside the repository. 7451 * 7452 * @deprecated Provided for backwards compatibility with the 1.4 API. 7453 */ 7454typedef svn_error_t *(*svn_wc_relocation_validator2_t)(void *baton, 7455 const char *uuid, 7456 const char *url, 7457 svn_boolean_t root, 7458 apr_pool_t *pool); 7459 7460/** Similar to #svn_wc_relocation_validator2_t, but without 7461 * the @a root and @a pool arguments. @a uuid will not be NULL in this version 7462 * of the function. 7463 * 7464 * @deprecated Provided for backwards compatibility with the 1.3 API. 7465 */ 7466typedef svn_error_t *(*svn_wc_relocation_validator_t)(void *baton, 7467 const char *uuid, 7468 const char *url); 7469 7470/** Recursively change repository references at @a wcroot_abspath 7471 * (which is the root directory of a working copy). The pre-change 7472 * URL should begin with @a from, and the post-change URL will begin 7473 * with @a to. @a validator (and its baton, @a validator_baton), will 7474 * be called for the newly generated base URL and calculated repo 7475 * root. 7476 * 7477 * @a wc_ctx is an working copy context. 7478 * 7479 * @a scratch_pool will be used for temporary allocations. 7480 * 7481 * @since New in 1.7. 7482 */ 7483svn_error_t * 7484svn_wc_relocate4(svn_wc_context_t *wc_ctx, 7485 const char *wcroot_abspath, 7486 const char *from, 7487 const char *to, 7488 svn_wc_relocation_validator3_t validator, 7489 void *validator_baton, 7490 apr_pool_t *scratch_pool); 7491 7492/** Similar to svn_wc_relocate4(), but with a #svn_wc_adm_access_t / 7493 * relative path parameter pair. 7494 * 7495 * @note As of the 1.7 API, @a path is required to be a working copy 7496 * root directory, and @a recurse is required to be TRUE. 7497 * 7498 * @since New in 1.5. 7499 * @deprecated Provided for limited backwards compatibility with the 7500 * 1.6 API. 7501 */ 7502SVN_DEPRECATED 7503svn_error_t * 7504svn_wc_relocate3(const char *path, 7505 svn_wc_adm_access_t *adm_access, 7506 const char *from, 7507 const char *to, 7508 svn_boolean_t recurse, 7509 svn_wc_relocation_validator3_t validator, 7510 void *validator_baton, 7511 apr_pool_t *pool); 7512 7513/** Similar to svn_wc_relocate3(), but uses #svn_wc_relocation_validator2_t. 7514 * 7515 * @since New in 1.4. 7516 * @deprecated Provided for backwards compatibility with the 1.4 API. */ 7517SVN_DEPRECATED 7518svn_error_t * 7519svn_wc_relocate2(const char *path, 7520 svn_wc_adm_access_t *adm_access, 7521 const char *from, 7522 const char *to, 7523 svn_boolean_t recurse, 7524 svn_wc_relocation_validator2_t validator, 7525 void *validator_baton, 7526 apr_pool_t *pool); 7527 7528/** Similar to svn_wc_relocate2(), but uses #svn_wc_relocation_validator_t. 7529 * 7530 * @deprecated Provided for backwards compatibility with the 1.3 API. */ 7531SVN_DEPRECATED 7532svn_error_t * 7533svn_wc_relocate(const char *path, 7534 svn_wc_adm_access_t *adm_access, 7535 const char *from, 7536 const char *to, 7537 svn_boolean_t recurse, 7538 svn_wc_relocation_validator_t validator, 7539 void *validator_baton, 7540 apr_pool_t *pool); 7541 7542 7543/** 7544 * Revert changes to @a local_abspath. Perform necessary allocations in 7545 * @a scratch_pool. 7546 * 7547 * @a wc_ctx contains the necessary locks required for performing the 7548 * operation. 7549 * 7550 * If @a depth is #svn_depth_empty, revert just @a path (if a 7551 * directory, then revert just the properties on that directory). 7552 * Else if #svn_depth_files, revert @a path and any files 7553 * directly under @a path if it is directory. Else if 7554 * #svn_depth_immediates, revert all of the preceding plus 7555 * properties on immediate subdirectories; else if #svn_depth_infinity, 7556 * revert path and everything under it fully recursively. 7557 * 7558 * @a changelist_filter is an array of <tt>const char *</tt> changelist 7559 * names, used as a restrictive filter on items reverted; that is, 7560 * don't revert any item unless it's a member of one of those 7561 * changelists. If @a changelist_filter is empty (or altogether @c NULL), 7562 * no changelist filtering occurs. 7563 * 7564 * If @a clear_changelists is TRUE, then changelist information for the 7565 * paths is cleared. 7566 * 7567 * If @a metadata_only is TRUE, the working copy files are untouched, but 7568 * if there are conflict marker files attached to these files these 7569 * markers are removed. 7570 * 7571 * If @a cancel_func is non-NULL, call it with @a cancel_baton at 7572 * various points during the reversion process. If it returns an 7573 * error (typically #SVN_ERR_CANCELLED), return that error 7574 * immediately. 7575 * 7576 * If @a use_commit_times is TRUE, then all reverted working-files 7577 * will have their timestamp set to the last-committed-time. If 7578 * FALSE, the reverted working-files will be touched with the 'now' time. 7579 * 7580 * For each item reverted, @a notify_func will be called with @a notify_baton 7581 * and the path of the reverted item. @a notify_func may be @c NULL if this 7582 * notification is not needed. 7583 * 7584 * If @a path is not under version control, return the error 7585 * #SVN_ERR_UNVERSIONED_RESOURCE. 7586 * 7587 * @since New in 1.9. 7588 */ 7589svn_error_t * 7590svn_wc_revert5(svn_wc_context_t *wc_ctx, 7591 const char *local_abspath, 7592 svn_depth_t depth, 7593 svn_boolean_t use_commit_times, 7594 const apr_array_header_t *changelist_filter, 7595 svn_boolean_t clear_changelists, 7596 svn_boolean_t metadata_only, 7597 svn_cancel_func_t cancel_func, 7598 void *cancel_baton, 7599 svn_wc_notify_func2_t notify_func, 7600 void *notify_baton, 7601 apr_pool_t *scratch_pool); 7602 7603/** Similar to svn_wc_revert5() but with @a clear_changelists always set to 7604 * FALSE and @a metadata_only set to FALSE. 7605 * 7606 * @since New in 1.7. 7607 * @deprecated Provided for backward compatibility with the 1.8 API. 7608 */ 7609SVN_DEPRECATED 7610svn_error_t * 7611svn_wc_revert4(svn_wc_context_t *wc_ctx, 7612 const char *local_abspath, 7613 svn_depth_t depth, 7614 svn_boolean_t use_commit_times, 7615 const apr_array_header_t *changelist_filter, 7616 svn_cancel_func_t cancel_func, 7617 void *cancel_baton, 7618 svn_wc_notify_func2_t notify_func, 7619 void *notify_baton, 7620 apr_pool_t *scratch_pool); 7621 7622/** Similar to svn_wc_revert4() but takes a relative path and access baton. 7623 * 7624 * @since New in 1.5. 7625 * @deprecated Provided for backward compatibility with the 1.6 API. 7626 */ 7627SVN_DEPRECATED 7628svn_error_t * 7629svn_wc_revert3(const char *path, 7630 svn_wc_adm_access_t *parent_access, 7631 svn_depth_t depth, 7632 svn_boolean_t use_commit_times, 7633 const apr_array_header_t *changelist_filter, 7634 svn_cancel_func_t cancel_func, 7635 void *cancel_baton, 7636 svn_wc_notify_func2_t notify_func, 7637 void *notify_baton, 7638 apr_pool_t *pool); 7639 7640/** 7641 * Similar to svn_wc_revert3(), but with @a changelist_filter passed as @c 7642 * NULL, and @a depth set according to @a recursive: if @a recursive 7643 * is TRUE, @a depth is #svn_depth_infinity; if FALSE, @a depth is 7644 * #svn_depth_empty. 7645 * 7646 * @note Most APIs map @a recurse==FALSE to @a depth==svn_depth_files; 7647 * revert is deliberately different. 7648 * 7649 * @since New in 1.2. 7650 * @deprecated Provided for backward compatibility with the 1.4 API. 7651 */ 7652SVN_DEPRECATED 7653svn_error_t * 7654svn_wc_revert2(const char *path, 7655 svn_wc_adm_access_t *parent_access, 7656 svn_boolean_t recursive, 7657 svn_boolean_t use_commit_times, 7658 svn_cancel_func_t cancel_func, 7659 void *cancel_baton, 7660 svn_wc_notify_func2_t notify_func, 7661 void *notify_baton, 7662 apr_pool_t *pool); 7663 7664/** 7665 * Similar to svn_wc_revert2(), but takes an #svn_wc_notify_func_t instead. 7666 * 7667 * @deprecated Provided for backward compatibility with the 1.1 API. 7668 */ 7669SVN_DEPRECATED 7670svn_error_t * 7671svn_wc_revert(const char *path, 7672 svn_wc_adm_access_t *parent_access, 7673 svn_boolean_t recursive, 7674 svn_boolean_t use_commit_times, 7675 svn_cancel_func_t cancel_func, 7676 void *cancel_baton, 7677 svn_wc_notify_func_t notify_func, 7678 void *notify_baton, 7679 apr_pool_t *pool); 7680 7681/** 7682 * Restores a missing node, @a local_abspath using the @a wc_ctx. Records 7683 * the new last modified time of the file for status processing. 7684 * 7685 * If @a use_commit_times is TRUE, then set restored files' timestamps 7686 * to their last-commit-times. 7687 * 7688 * Returns SVN_ERROR_WC_PATH_NOT_FOUND if LOCAL_ABSPATH is not versioned and 7689 * SVN_ERROR_WC_PATH_UNEXPECTED_STATUS if LOCAL_ABSPATH is in a status where 7690 * it can't be restored. 7691 * 7692 * @since New in 1.7. 7693 */ 7694svn_error_t * 7695svn_wc_restore(svn_wc_context_t *wc_ctx, 7696 const char *local_abspath, 7697 svn_boolean_t use_commit_times, 7698 apr_pool_t *scratch_pool); 7699 7700 7701/* Tmp files */ 7702 7703/** Create a unique temporary file in administrative tmp/ area of 7704 * directory @a path. Return a handle in @a *fp and the path 7705 * in @a *new_name. Either @a fp or @a new_name can be NULL. 7706 * 7707 * The flags will be <tt>APR_WRITE | APR_CREATE | APR_EXCL</tt> and 7708 * optionally @c APR_DELONCLOSE (if the @a delete_when argument is 7709 * set to #svn_io_file_del_on_close). 7710 * 7711 * This means that as soon as @a fp is closed, the tmp file will vanish. 7712 * 7713 * @since New in 1.4 7714 * @deprecated For compatibility with 1.6 API 7715 */ 7716SVN_DEPRECATED 7717svn_error_t * 7718svn_wc_create_tmp_file2(apr_file_t **fp, 7719 const char **new_name, 7720 const char *path, 7721 svn_io_file_del_t delete_when, 7722 apr_pool_t *pool); 7723 7724 7725/** Same as svn_wc_create_tmp_file2(), but with @a new_name set to @c NULL, 7726 * and without the ability to delete the file on pool cleanup. 7727 * 7728 * @deprecated For compatibility with 1.3 API 7729 */ 7730SVN_DEPRECATED 7731svn_error_t * 7732svn_wc_create_tmp_file(apr_file_t **fp, 7733 const char *path, 7734 svn_boolean_t delete_on_close, 7735 apr_pool_t *pool); 7736 7737 7738/** 7739 * @defgroup svn_wc_translate EOL conversion and keyword expansion 7740 * @{ 7741 */ 7742 7743 7744/** Set @a xlated_path to a translated copy of @a src 7745 * or to @a src itself if no translation is necessary. 7746 * That is, if @a versioned_file's properties indicate newline conversion or 7747 * keyword expansion, point @a *xlated_path to a copy of @a src 7748 * whose newlines and keywords are converted using the translation 7749 * as requested by @a flags. 7750 * 7751 * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine 7752 * if the client has canceled the operation. 7753 * 7754 * When translating to the normal form, inconsistent eol styles will be 7755 * repaired when appropriate for the given setting. When translating 7756 * from normal form, no EOL repair is performed (consistency is assumed). 7757 * This behaviour can be overridden by specifying 7758 * #SVN_WC_TRANSLATE_FORCE_EOL_REPAIR. 7759 * 7760 * The caller can explicitly request a new file to be returned by setting the 7761 * #SVN_WC_TRANSLATE_FORCE_COPY flag in @a flags. 7762 * 7763 * This function is generally used to get a file that can be compared 7764 * meaningfully against @a versioned_file's text base, if 7765 * @c SVN_WC_TRANSLATE_TO_NF is specified, against @a versioned_file itself 7766 * if @c SVN_WC_TRANSLATE_FROM_NF is specified. 7767 * 7768 * If a new output file is created, it is created in the temp file area 7769 * belonging to @a versioned_file. By default it will be deleted at pool 7770 * cleanup. If @c SVN_WC_TRANSLATE_NO_OUTPUT_CLEANUP is specified, the 7771 * default pool cleanup handler to remove @a *xlated_path is not registered. 7772 * If the input file is returned as the output, its lifetime is not 7773 * specified. 7774 * 7775 * If an error is returned, the effect on @a *xlated_path is undefined. 7776 * 7777 * @since New in 1.4 7778 * @deprecated Provided for compatibility with the 1.6 API 7779 */ 7780SVN_DEPRECATED 7781svn_error_t * 7782svn_wc_translated_file2(const char **xlated_path, 7783 const char *src, 7784 const char *versioned_file, 7785 svn_wc_adm_access_t *adm_access, 7786 apr_uint32_t flags, 7787 apr_pool_t *pool); 7788 7789 7790/** Same as svn_wc_translated_file2, but will never clean up 7791 * temporary files. 7792 * 7793 * @deprecated Provided for compatibility with the 1.3 API 7794 */ 7795SVN_DEPRECATED 7796svn_error_t * 7797svn_wc_translated_file(const char **xlated_p, 7798 const char *vfile, 7799 svn_wc_adm_access_t *adm_access, 7800 svn_boolean_t force_repair, 7801 apr_pool_t *pool); 7802 7803 7804/** Returns a @a stream allocated in @a pool with access to the given 7805 * @a path taking the file properties from @a versioned_file using 7806 * @a adm_access. 7807 * 7808 * If @a flags includes #SVN_WC_TRANSLATE_FROM_NF, the stream will 7809 * translate from Normal Form to working copy form while writing to 7810 * @a path; stream read operations are not supported. 7811 * Conversely, if @a flags includes #SVN_WC_TRANSLATE_TO_NF, the stream will 7812 * translate from working copy form to Normal Form while reading from 7813 * @a path; stream write operations are not supported. 7814 * 7815 * The @a flags are the same constants as those used for 7816 * svn_wc_translated_file2(). 7817 * 7818 * @since New in 1.5. 7819 * @deprecated Provided for compatibility with the 1.6 API. 7820 */ 7821SVN_DEPRECATED 7822svn_error_t * 7823svn_wc_translated_stream(svn_stream_t **stream, 7824 const char *path, 7825 const char *versioned_file, 7826 svn_wc_adm_access_t *adm_access, 7827 apr_uint32_t flags, 7828 apr_pool_t *pool); 7829 7830/** @} */ 7831 7832 7833/** 7834 * @defgroup svn_wc_deltas Text/Prop Deltas Using an Editor 7835 * @{ 7836 */ 7837 7838/** Send the local modifications for versioned file @a local_abspath (with 7839 * matching @a file_baton) through @a editor, then close @a file_baton 7840 * afterwards. Use @a scratch_pool for any temporary allocation. 7841 * 7842 * If @a new_text_base_md5_checksum is non-NULL, set 7843 * @a *new_text_base_md5_checksum to the MD5 checksum of (@a local_abspath 7844 * translated to repository-normal form), allocated in @a result_pool. 7845 * 7846 * If @a new_text_base_sha1_checksum in non-NULL, store a copy of (@a 7847 * local_abspath translated to repository-normal form) in the pristine text 7848 * store, and set @a *new_text_base_sha1_checksum to its SHA-1 checksum. 7849 * 7850 * If @a fulltext, send the untranslated copy of @a local_abspath through 7851 * @a editor as full-text; else send it as svndiff against the current text 7852 * base. 7853 * 7854 * If sending a diff, and the recorded checksum for @a local_abspath's 7855 * text-base does not match the current actual checksum, then remove the tmp 7856 * copy (and set @a *tempfile to NULL if appropriate), and return the 7857 * error #SVN_ERR_WC_CORRUPT_TEXT_BASE. 7858 * 7859 * @note This is intended for use with both infix and postfix 7860 * text-delta styled editor drivers. 7861 * 7862 * @since New in 1.7. 7863 */ 7864svn_error_t * 7865svn_wc_transmit_text_deltas3(const svn_checksum_t **new_text_base_md5_checksum, 7866 const svn_checksum_t **new_text_base_sha1_checksum, 7867 svn_wc_context_t *wc_ctx, 7868 const char *local_abspath, 7869 svn_boolean_t fulltext, 7870 const svn_delta_editor_t *editor, 7871 void *file_baton, 7872 apr_pool_t *result_pool, 7873 apr_pool_t *scratch_pool); 7874 7875/** Similar to svn_wc_transmit_text_deltas3(), but with a relative path 7876 * and adm_access baton, and the checksum output is an MD5 digest instead of 7877 * two svn_checksum_t objects. 7878 * 7879 * If @a tempfile is non-NULL, make a copy of @a path with keywords 7880 * and eol translated to repository-normal form, and set @a *tempfile to the 7881 * absolute path to this copy, allocated in @a result_pool. The copy will 7882 * be in the temporary-text-base directory. Do not clean up the copy; 7883 * caller can do that. (The purpose of handing back the tmp copy is that it 7884 * is usually about to become the new text base anyway, but the installation 7885 * of the new text base is outside the scope of this function.) 7886 * 7887 * @since New in 1.4. 7888 * @deprecated Provided for backwards compatibility with the 1.6 API. 7889 */ 7890SVN_DEPRECATED 7891svn_error_t * 7892svn_wc_transmit_text_deltas2(const char **tempfile, 7893 unsigned char digest[], 7894 const char *path, 7895 svn_wc_adm_access_t *adm_access, 7896 svn_boolean_t fulltext, 7897 const svn_delta_editor_t *editor, 7898 void *file_baton, 7899 apr_pool_t *pool); 7900 7901/** Similar to svn_wc_transmit_text_deltas2(), but with @a digest set to NULL. 7902 * 7903 * @deprecated Provided for backwards compatibility with the 1.3 API. 7904 */ 7905SVN_DEPRECATED 7906svn_error_t * 7907svn_wc_transmit_text_deltas(const char *path, 7908 svn_wc_adm_access_t *adm_access, 7909 svn_boolean_t fulltext, 7910 const svn_delta_editor_t *editor, 7911 void *file_baton, 7912 const char **tempfile, 7913 apr_pool_t *pool); 7914 7915 7916/** Given a @a local_abspath, transmit all local property 7917 * modifications using the appropriate @a editor method (in conjunction 7918 * with @a baton). Use @a scratch_pool for any temporary allocation. 7919 * 7920 * @since New in 1.7. 7921 */ 7922svn_error_t * 7923svn_wc_transmit_prop_deltas2(svn_wc_context_t *wc_ctx, 7924 const char *local_abspath, 7925 const svn_delta_editor_t *editor, 7926 void *baton, 7927 apr_pool_t *scratch_pool); 7928 7929 7930/** Similar to svn_wc_transmit_prop_deltas2(), but with a relative path, 7931 * adm_access baton and tempfile. 7932 * 7933 * If a temporary file remains after this function is finished, the 7934 * path to that file is returned in @a *tempfile (so the caller can 7935 * clean this up if it wishes to do so). 7936 * 7937 * @note Starting version 1.5, no tempfile will ever be returned 7938 * anymore. If @a *tempfile is passed, its value is set to @c NULL. 7939 * 7940 * @deprecated Provided for backwards compatibility with the 1.6 API. 7941 */ 7942SVN_DEPRECATED 7943svn_error_t * 7944svn_wc_transmit_prop_deltas(const char *path, 7945 svn_wc_adm_access_t *adm_access, 7946 const svn_wc_entry_t *entry, 7947 const svn_delta_editor_t *editor, 7948 void *baton, 7949 const char **tempfile, 7950 apr_pool_t *pool); 7951 7952/** @} */ 7953 7954 7955/** 7956 * @defgroup svn_wc_ignore Ignoring unversioned files and directories 7957 * @{ 7958 */ 7959 7960/** Get the run-time configured list of ignore patterns from the 7961 * #svn_config_t's in the @a config hash, and store them in @a *patterns. 7962 * Allocate @a *patterns and its contents in @a pool. 7963 */ 7964svn_error_t * 7965svn_wc_get_default_ignores(apr_array_header_t **patterns, 7966 apr_hash_t *config, 7967 apr_pool_t *pool); 7968 7969/** Get the list of ignore patterns from the #svn_config_t's in the 7970 * @a config hash and the local ignore patterns from the directory 7971 * at @a local_abspath, using @a wc_ctx, and store them in @a *patterns. 7972 * Allocate @a *patterns and its contents in @a result_pool, use @a 7973 * scratch_pool for temporary allocations. 7974 * 7975 * @since New in 1.7. 7976 */ 7977svn_error_t * 7978svn_wc_get_ignores2(apr_array_header_t **patterns, 7979 svn_wc_context_t *wc_ctx, 7980 const char *local_abspath, 7981 apr_hash_t *config, 7982 apr_pool_t *result_pool, 7983 apr_pool_t *scratch_pool); 7984 7985/** Similar to svn_wc_get_ignores2(), but with a #svn_wc_adm_access_t 7986 * parameter in place of #svn_wc_context_t and @c local_abspath parameters. 7987 * 7988 * @since New in 1.3. 7989 * @deprecated Provided for backwards compatibility with the 1.6 API. 7990 */ 7991SVN_DEPRECATED 7992svn_error_t * 7993svn_wc_get_ignores(apr_array_header_t **patterns, 7994 apr_hash_t *config, 7995 svn_wc_adm_access_t *adm_access, 7996 apr_pool_t *pool); 7997 7998/** Return TRUE iff @a str matches any of the elements of @a list, a 7999 * list of zero or more ignore patterns. 8000 * 8001 * @since New in 1.5. 8002 */ 8003svn_boolean_t 8004svn_wc_match_ignore_list(const char *str, 8005 const apr_array_header_t *list, 8006 apr_pool_t *pool); 8007 8008/** @} */ 8009 8010 8011/** 8012 * @defgroup svn_wc_repos_locks Repository locks 8013 * @{ 8014 */ 8015 8016/** Add @a lock to the working copy for @a local_abspath. If @a 8017 * local_abspath is read-only, due to locking properties, make it writable. 8018 * Perform temporary allocations in @a scratch_pool. 8019 * 8020 * @since New in 1.7. 8021 */ 8022svn_error_t * 8023svn_wc_add_lock2(svn_wc_context_t *wc_ctx, 8024 const char *abspath, 8025 const svn_lock_t *lock, 8026 apr_pool_t *scratch_pool); 8027 8028/** 8029 * Similar to svn_wc_add_lock2(), but with a #svn_wc_adm_access_t / 8030 * relative path parameter pair. 8031 * 8032 * @deprecated Provided for backward compatibility with the 1.6 API. 8033 * @since New in 1.2. 8034 */ 8035SVN_DEPRECATED 8036svn_error_t * 8037svn_wc_add_lock(const char *path, 8038 const svn_lock_t *lock, 8039 svn_wc_adm_access_t *adm_access, 8040 apr_pool_t *pool); 8041 8042/** Remove any lock from @a local_abspath. If @a local_abspath has a 8043 * lock and the locking so specifies, make the file read-only. Don't 8044 * return an error if @a local_abspath didn't have a lock. Perform temporary 8045 * allocations in @a scratch_pool. 8046 * 8047 * @since New in 1.7. 8048 */ 8049svn_error_t * 8050svn_wc_remove_lock2(svn_wc_context_t *wc_ctx, 8051 const char *local_abspath, 8052 apr_pool_t *scratch_pool); 8053 8054/** 8055 * Similar to svn_wc_remove_lock2(), but with a #svn_wc_adm_access_t / 8056 * relative path parameter pair. 8057 * 8058 * @deprecated Provided for backward compatibility with the 1.6 API. 8059 * @since New in 1.2. 8060 */ 8061SVN_DEPRECATED 8062svn_error_t * 8063svn_wc_remove_lock(const char *path, 8064 svn_wc_adm_access_t *adm_access, 8065 apr_pool_t *pool); 8066 8067/** @} */ 8068 8069 8070/** A structure to report a summary of a working copy, including the 8071 * mix of revisions found within it, whether any parts are switched or 8072 * locally modified, and whether it is a sparse checkout. 8073 * 8074 * @note Fields may be added to the end of this structure in future 8075 * versions. Therefore, to preserve binary compatibility, users 8076 * should not directly allocate structures of this type. 8077 * 8078 * @since New in 1.4 8079 */ 8080typedef struct svn_wc_revision_status_t 8081{ 8082 svn_revnum_t min_rev; /**< Lowest revision found */ 8083 svn_revnum_t max_rev; /**< Highest revision found */ 8084 8085 svn_boolean_t switched; /**< Is anything switched? */ 8086 svn_boolean_t modified; /**< Is anything modified? */ 8087 8088 /** Whether any WC paths are at a depth other than #svn_depth_infinity or 8089 * are user excluded. 8090 * @since New in 1.5. 8091 */ 8092 svn_boolean_t sparse_checkout; 8093} svn_wc_revision_status_t; 8094 8095/** Set @a *result_p to point to a new #svn_wc_revision_status_t structure 8096 * containing a summary of the revision range and status of the working copy 8097 * at @a local_abspath (not including "externals"). @a local_abspath must 8098 * be absolute. Return SVN_ERR_WC_PATH_NOT_FOUND if @a local_abspath is not 8099 * a working copy path. 8100 * 8101 * Set @a (*result_p)->min_rev and @a (*result_p)->max_rev respectively to the 8102 * lowest and highest revision numbers in the working copy. If @a committed 8103 * is TRUE, summarize the last-changed revisions, else the base revisions. 8104 * 8105 * Set @a (*result_p)->switched to indicate whether any item in the WC is 8106 * switched relative to its parent. If @a trail_url is non-NULL, use it to 8107 * determine if @a local_abspath itself is switched. It should be any trailing 8108 * portion of @a local_abspath's expected URL, long enough to include any parts 8109 * that the caller considers might be changed by a switch. If it does not 8110 * match the end of @a local_abspath's actual URL, then report a "switched" 8111 * status. 8112 * 8113 * Set @a (*result_p)->modified to indicate whether any item is locally 8114 * modified. 8115 * 8116 * If @a cancel_func is non-NULL, call it with @a cancel_baton to determine 8117 * if the client has canceled the operation. 8118 * 8119 * Allocate *result_p in @a result_pool, use @a scratch_pool for temporary 8120 * allocations. 8121 * 8122 * @a wc_ctx should be a valid working copy context. 8123 * 8124 * @since New in 1.7 8125 */ 8126svn_error_t * 8127svn_wc_revision_status2(svn_wc_revision_status_t **result_p, 8128 svn_wc_context_t *wc_ctx, 8129 const char *local_abspath, 8130 const char *trail_url, 8131 svn_boolean_t committed, 8132 svn_cancel_func_t cancel_func, 8133 void *cancel_baton, 8134 apr_pool_t *result_pool, 8135 apr_pool_t *scratch_pool); 8136 8137 8138/** Similar to svn_wc_revision_status2(), but with a (possibly) local 8139 * path and no wc_ctx parameter. 8140 * 8141 * @since New in 1.4. 8142 * @deprecated Provided for backward compatibility with the 1.6 API. 8143 */ 8144SVN_DEPRECATED 8145svn_error_t * 8146svn_wc_revision_status(svn_wc_revision_status_t **result_p, 8147 const char *wc_path, 8148 const char *trail_url, 8149 svn_boolean_t committed, 8150 svn_cancel_func_t cancel_func, 8151 void *cancel_baton, 8152 apr_pool_t *pool); 8153 8154 8155/** 8156 * Set @a local_abspath's 'changelist' attribute to @a changelist iff 8157 * @a changelist is not @c NULL; otherwise, remove any current 8158 * changelist assignment from @a local_abspath. @a changelist may not 8159 * be the empty string. Recurse to @a depth. 8160 * 8161 * @a changelist_filter is an array of <tt>const char *</tt> changelist 8162 * names, used as a restrictive filter on items whose changelist 8163 * assignments are adjusted; that is, don't tweak the changeset of any 8164 * item unless it's currently a member of one of those changelists. 8165 * If @a changelist_filter is empty (or altogether @c NULL), no changelist 8166 * filtering occurs. 8167 * 8168 * If @a cancel_func is not @c NULL, call it with @a cancel_baton to 8169 * determine if the client has canceled the operation. 8170 * 8171 * If @a notify_func is not @c NULL, call it with @a notify_baton to 8172 * report the change (using notification types 8173 * #svn_wc_notify_changelist_set and #svn_wc_notify_changelist_clear). 8174 * 8175 * Use @a scratch_pool for temporary allocations. 8176 * 8177 * @note For now, directories are NOT allowed to be associated with 8178 * changelists; there is confusion about whether they should behave 8179 * as depth-0 or depth-infinity objects. If @a local_abspath is a directory, 8180 * return an error. 8181 * 8182 * @note This metadata is purely a client-side "bookkeeping" 8183 * convenience, and is entirely managed by the working copy. 8184 * 8185 * @since New in 1.7. 8186 */ 8187svn_error_t * 8188svn_wc_set_changelist2(svn_wc_context_t *wc_ctx, 8189 const char *local_abspath, 8190 const char *changelist, 8191 svn_depth_t depth, 8192 const apr_array_header_t *changelist_filter, 8193 svn_cancel_func_t cancel_func, 8194 void *cancel_baton, 8195 svn_wc_notify_func2_t notify_func, 8196 void *notify_baton, 8197 apr_pool_t *scratch_pool); 8198 8199/** Similar to svn_wc_set_changelist2(), but with an access baton and 8200 * relative path. 8201 * 8202 * @since New in 1.5. 8203 * @deprecated Provided for backward compatibility with the 1.6 API. 8204 */ 8205SVN_DEPRECATED 8206svn_error_t * 8207svn_wc_set_changelist(const char *path, 8208 const char *changelist, 8209 svn_wc_adm_access_t *adm_access, 8210 svn_cancel_func_t cancel_func, 8211 void *cancel_baton, 8212 svn_wc_notify_func2_t notify_func, 8213 void *notify_baton, 8214 apr_pool_t *pool); 8215 8216 8217 8218/** 8219 * The callback type used by svn_wc_get_changelists() and 8220 * svn_client_get_changelists(). 8221 * 8222 * On each invocation, @a path is a newly discovered member of the 8223 * changelist, and @a baton is a private function closure. 8224 * 8225 * @since New in 1.5. 8226 */ 8227typedef svn_error_t *(*svn_changelist_receiver_t) (void *baton, 8228 const char *path, 8229 const char *changelist, 8230 apr_pool_t *pool); 8231 8232 8233/** 8234 * Beginning at @a local_abspath, crawl to @a depth to discover every path in 8235 * or under @a local_abspath which belongs to one of the changelists in @a 8236 * changelist_filter (an array of <tt>const char *</tt> changelist names). 8237 * If @a changelist_filter is @c NULL, discover paths with any changelist. 8238 * Call @a callback_func (with @a callback_baton) each time a 8239 * changelist-having path is discovered. 8240 * 8241 * @a local_abspath is a local WC path. 8242 * 8243 * If @a cancel_func is not @c NULL, invoke it passing @a cancel_baton 8244 * during the recursive walk. 8245 * 8246 * @since New in 1.7. 8247 */ 8248svn_error_t * 8249svn_wc_get_changelists(svn_wc_context_t *wc_ctx, 8250 const char *local_abspath, 8251 svn_depth_t depth, 8252 const apr_array_header_t *changelist_filter, 8253 svn_changelist_receiver_t callback_func, 8254 void *callback_baton, 8255 svn_cancel_func_t cancel_func, 8256 void *cancel_baton, 8257 apr_pool_t *scratch_pool); 8258 8259 8260/** Crop @a local_abspath according to @a depth. 8261 * 8262 * Remove any item that exceeds the boundary of @a depth (relative to 8263 * @a local_abspath) from revision control. Leave modified items behind 8264 * (unversioned), while removing unmodified ones completely. 8265 * 8266 * @a depth can be svn_depth_empty, svn_depth_files or svn_depth_immediates. 8267 * Excluding nodes is handled by svn_wc_exclude(). 8268 * 8269 * If @a local_abspath starts out with a shallower depth than @a depth, 8270 * do not upgrade it to @a depth (that would not be cropping); however, do 8271 * check children and crop them appropriately according to @a depth. 8272 * 8273 * Returns immediately with an #SVN_ERR_UNSUPPORTED_FEATURE error if @a 8274 * local_abspath is not a directory, or if @a depth is not restrictive 8275 * (e.g., #svn_depth_infinity). 8276 * 8277 * @a wc_ctx contains a tree lock, for the local path to the working copy 8278 * which will be used as the root of this operation. 8279 * 8280 * If @a cancel_func is not @c NULL, call it with @a cancel_baton at 8281 * various points to determine if the client has canceled the operation. 8282 * 8283 * If @a notify_func is not @c NULL, call it with @a notify_baton to 8284 * report changes as they are made. 8285 * 8286 * @since New in 1.7 8287 */ 8288svn_error_t * 8289svn_wc_crop_tree2(svn_wc_context_t *wc_ctx, 8290 const char *local_abspath, 8291 svn_depth_t depth, 8292 svn_cancel_func_t cancel_func, 8293 void *cancel_baton, 8294 svn_wc_notify_func2_t notify_func, 8295 void *notify_baton, 8296 apr_pool_t *scratch_pool); 8297 8298/** Similar to svn_wc_crop_tree2(), but uses an access baton and target. 8299 * 8300 * svn_wc_crop_tree() also allows #svn_depth_exclude, which is now 8301 * handled via svn_wc_exclude() 8302 * 8303 * @a target is a basename in @a anchor or "" for @a anchor itself. 8304 * 8305 * @since New in 1.6 8306 * @deprecated Provided for backward compatibility with the 1.6 API. 8307 */ 8308SVN_DEPRECATED 8309svn_error_t * 8310svn_wc_crop_tree(svn_wc_adm_access_t *anchor, 8311 const char *target, 8312 svn_depth_t depth, 8313 svn_wc_notify_func2_t notify_func, 8314 void *notify_baton, 8315 svn_cancel_func_t cancel_func, 8316 void *cancel_baton, 8317 apr_pool_t *pool); 8318 8319/** Remove the local node for @a local_abspath from the working copy and 8320 * add an excluded node placeholder in its place. 8321 * 8322 * This feature is only supported for unmodified nodes. An 8323 * #SVN_ERR_UNSUPPORTED_FEATURE error is returned if the node can't be 8324 * excluded in its current state. 8325 * 8326 * @a wc_ctx contains a tree lock, for the local path to the working copy 8327 * which will be used as the root of this operation 8328 * 8329 * If @a notify_func is not @c NULL, call it with @a notify_baton to 8330 * report changes as they are made. 8331 * 8332 * If @a cancel_func is not @c NULL, call it with @a cancel_baton at 8333 * various points to determine if the client has canceled the operation. 8334 * 8335 * 8336 * @since New in 1.7 8337 */ 8338svn_error_t * 8339svn_wc_exclude(svn_wc_context_t *wc_ctx, 8340 const char *local_abspath, 8341 svn_cancel_func_t cancel_func, 8342 void *cancel_baton, 8343 svn_wc_notify_func2_t notify_func, 8344 void *notify_baton, 8345 apr_pool_t *scratch_pool); 8346 8347 8348/** @} */ 8349 8350/** 8351 * Set @a kind to the #svn_node_kind_t of @a abspath. Use @a wc_ctx to access 8352 * the working copy, and @a scratch_pool for all temporary allocations. 8353 * 8354 * If @a abspath is not under version control, set @a kind to #svn_node_none. 8355 * 8356 * If @a show_hidden and @a show_deleted are both @c FALSE, the kind of 8357 * scheduled for delete, administrative only 'not present' and excluded 8358 * nodes is reported as #svn_node_none. This is recommended as a check 8359 * for 'is there a versioned file or directory here?' 8360 * 8361 * If @a show_deleted is FALSE, but @a show_hidden is @c TRUE then only 8362 * scheduled for delete and administrative only 'not present' nodes are 8363 * reported as #svn_node_none. This is recommended as check for 8364 * 'Can I add a node here?' 8365 * 8366 * If @a show_deleted is TRUE, but @a show_hidden is FALSE, then only 8367 * administrative only 'not present' nodes and excluded nodes are reported as 8368 * #svn_node_none. This behavior is the behavior bescribed as 'hidden' 8369 * before Subversion 1.7. 8370 * 8371 * If @a show_hidden and @a show_deleted are both @c TRUE all nodes are 8372 * reported. 8373 * 8374 * @since New in 1.8. 8375 */ 8376svn_error_t * 8377svn_wc_read_kind2(svn_node_kind_t *kind, 8378 svn_wc_context_t *wc_ctx, 8379 const char *local_abspath, 8380 svn_boolean_t show_deleted, 8381 svn_boolean_t show_hidden, 8382 apr_pool_t *scratch_pool); 8383 8384/** Similar to svn_wc_read_kind2() but with @a show_deleted always 8385 * passed as TRUE. 8386 * 8387 * @since New in 1.7. 8388 * @deprecated Provided for backward compatibility with the 1.7 API. 8389 */ 8390SVN_DEPRECATED 8391svn_error_t * 8392svn_wc_read_kind(svn_node_kind_t *kind, 8393 svn_wc_context_t *wc_ctx, 8394 const char *abspath, 8395 svn_boolean_t show_hidden, 8396 apr_pool_t *scratch_pool); 8397 8398 8399/** @} */ 8400 8401#ifdef __cplusplus 8402} 8403#endif /* __cplusplus */ 8404 8405#endif /* SVN_WC_H */ 8406