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