← Back to branch summary

~ubuntu-branches/debian/sid/subversion/sid

« back to all changes in this revision

Viewing changes to subversion/libsvn_fs_fs/dag.h

  • Committer: Package Import Robot
  • Author(s): James McCoy, Peter Samuelson, James McCoy
  • Date: 2014-01-12 19:48:33 UTC
  • mfrom: (0.2.10)
  • Revision ID: package-import@ubuntu.com-20140112194833-w3axfwksn296jn5x
Tags: 1.8.5-1
http://bugs.debian.org/725787
http://bugs.debian.org/507430
http://bugs.debian.org/734163
http://bugs.debian.org/601544
http://bugs.debian.org/687291
http://bugs.debian.org/273874
http://bugs.debian.org/690815
http://bugs.debian.org/654172
http://bugs.debian.org/678224
http://bugs.debian.org/566148
http://bugs.debian.org/734918
http://bugs.debian.org/722393
[ Peter Samuelson ]
* New upstream release.  (Closes: #725787) Rediff patches:
  - Remove apr-abi1 (applied upstream), rename apr-abi2 to apr-abi
  - Remove loosen-sqlite-version-check (shouldn't be needed)
  - Remove java-osgi-metadata (applied upstream)
  - svnmucc prompts for a changelog if none is provided. (Closes: #507430)
  - Remove fix-bdb-version-detection, upstream uses "apu-config --dbm-libs"
  - Remove ruby-test-wc (applied upstream)
  - Fix “svn diff -r N file” when file has svn:mime-type set.
    (Closes: #734163)
  - Support specifying an encoding for mod_dav_svn's environment in which
    hooks are run.  (Closes: #601544)
  - Fix ordering of “svnadmin dump” paths with certain APR versions.
    (Closes: #687291)
  - Provide a better error message when authentication fails with an
    svn+ssh:// URL.  (Closes: #273874)
  - Updated Polish translations.  (Closes: #690815)

[ James McCoy ]
* Remove all traces of libneon, replaced by libserf.
* patches/sqlite_3.8.x_workaround: Upstream fix for wc-queries-test test
  failurse.
* Run configure with --with-apache-libexecdir, which allows removing part of
  patches/rpath.
* Re-enable auth-test as upstream has fixed the problem of picking up
  libraries from the environment rather than the build tree.
  (Closes: #654172)
* Point LD_LIBRARY_PATH at the built auth libraries when running the svn
  command during the build.  (Closes: #678224)
* Add a NEWS entry describing how to configure mod_dav_svn to understand
  UTF-8.  (Closes: #566148)
* Remove ancient transitional package, libsvn-ruby.
* Enable compatibility with Sqlite3 versions back to Wheezy.
* Enable hardening flags.  (Closes: #734918)
* patches/build-fixes: Enable verbose build logs.
* Build against the default ruby version.  (Closes: #722393)

Show diffs side-by-side

added added

removed removed

Lines of Context:
subversion/libsvn_fs_fs/dag.h
81
81
/* Serialize a DAG node, except don't try to preserve the 'fs' member.
82
82
   Implements svn_cache__serialize_func_t */
83
83
svn_error_t *
84
 
svn_fs_fs__dag_serialize(char **data,
 
84
svn_fs_fs__dag_serialize(void **data,
85
85
                         apr_size_t *data_len,
86
86
                         void *in,
87
87
                         apr_pool_t *pool);
90
90
   Implements svn_cache__deserialize_func_t */
91
91
svn_error_t *
92
92
svn_fs_fs__dag_deserialize(void **out,
93
 
                           char *data,
 
93
                           void *data,
94
94
                           apr_size_t data_len,
95
95
                           apr_pool_t *pool);
96
96
 
121
121
 
122
122
 
123
123
/* Set *ID_P to the node revision ID of NODE's immediate predecessor,
124
 
   or NULL if NODE has no predecessor, allocating from POOL.
125
 
 
126
 
   Use POOL for all allocations, including to cache the node_revision in
127
 
   NODE.
 
124
   or NULL if NODE has no predecessor.
128
125
 */
129
126
svn_error_t *svn_fs_fs__dag_get_predecessor_id(const svn_fs_id_t **id_p,
130
 
                                               dag_node_t *node,
131
 
                                               apr_pool_t *pool);
 
127
                                               dag_node_t *node);
132
128
 
133
129
 
134
130
/* Set *COUNT to the number of predecessors NODE has (recursively), or
135
 
   -1 if not known, allocating from POOL.
136
 
 
137
 
   Use POOL for all allocations, including to cache the node_revision in
138
 
   NODE.
 
131
   -1 if not known.
139
132
 */
 
133
/* ### This function is currently only used by 'verify'. */
140
134
svn_error_t *svn_fs_fs__dag_get_predecessor_count(int *count,
141
 
                                                  dag_node_t *node,
142
 
                                                  apr_pool_t *pool);
 
135
                                                  dag_node_t *node);
143
136
 
144
137
/* Set *COUNT to the number of node under NODE (inclusive) with
145
 
   svn:mergeinfo properties, allocating from POOL.
146
 
 
147
 
   Use POOL for all allocations, including to cache the node_revision in
148
 
   NODE.
 
138
   svn:mergeinfo properties.
149
139
 */
150
140
svn_error_t *svn_fs_fs__dag_get_mergeinfo_count(apr_int64_t *count,
151
 
                                                dag_node_t *node,
152
 
                                                apr_pool_t *pool);
 
141
                                                dag_node_t *node);
153
142
 
154
143
/* Set *DO_THEY to a flag indicating whether or not NODE is a
155
144
   directory with at least one descendant (not including itself) with
156
145
   svn:mergeinfo.
157
 
 
158
 
   Use POOL for all allocations, including to cache the node_revision in
159
 
   NODE.
160
146
 */
161
147
svn_error_t *
162
148
svn_fs_fs__dag_has_descendants_with_mergeinfo(svn_boolean_t *do_they,
163
 
                                              dag_node_t *node,
164
 
                                              apr_pool_t *pool);
 
149
                                              dag_node_t *node);
165
150
 
166
151
/* Set *HAS_MERGEINFO to a flag indicating whether or not NODE itself
167
152
   has svn:mergeinfo set on it.
168
 
 
169
 
   Use POOL for all allocations, including to cache the node_revision in
170
 
   NODE.
171
153
 */
172
154
svn_error_t *
173
155
svn_fs_fs__dag_has_mergeinfo(svn_boolean_t *has_mergeinfo,
174
 
                             dag_node_t *node,
175
 
                             apr_pool_t *pool);
 
156
                             dag_node_t *node);
176
157
 
177
158
/* Return non-zero IFF NODE is currently mutable. */
178
159
svn_boolean_t svn_fs_fs__dag_check_mutable(const dag_node_t *node);
188
169
   If properties do not exist on NODE, *PROPLIST_P will be set to
189
170
   NULL.
190
171
 
191
 
   Use POOL for all allocations, including to cache the node_revision in
192
 
   NODE.
 
172
   Use POOL for all allocations.
193
173
 */
194
174
svn_error_t *svn_fs_fs__dag_get_proplist(apr_hash_t **proplist_p,
195
175
                                         dag_node_t *node,
198
178
/* Set the property list of NODE to PROPLIST, allocating from POOL.
199
179
   The node being changed must be mutable.
200
180
 
201
 
   Use POOL for all allocations, including to cache the node_revision in
202
 
   NODE.
 
181
   Use POOL for all allocations.
203
182
 */
204
183
svn_error_t *svn_fs_fs__dag_set_proplist(dag_node_t *node,
205
184
                                         apr_hash_t *proplist,
208
187
/* Increment the mergeinfo_count field on NODE by INCREMENT.  The node
209
188
   being changed must be mutable.
210
189
 
211
 
   Use POOL for all allocations, including to cache the node_revision in
212
 
   NODE.
 
190
   Use POOL for all allocations.
213
191
 */
214
192
svn_error_t *svn_fs_fs__dag_increment_mergeinfo_count(dag_node_t *node,
215
193
                                                      apr_int64_t increment,
218
196
/* Set the has-mergeinfo flag on NODE to HAS_MERGEINFO.  The node
219
197
   being changed must be mutable.
220
198
 
221
 
   Use POOL for all allocations, including to cache the node_revision in
222
 
   NODE.
 
199
   Use POOL for all allocations.
223
200
 */
224
201
svn_error_t *svn_fs_fs__dag_set_has_mergeinfo(dag_node_t *node,
225
202
                                              svn_boolean_t has_mergeinfo,
274
251
 
275
252
 
276
253
/* Open the node named NAME in the directory PARENT.  Set *CHILD_P to
277
 
   the new node, allocated in POOL.  NAME must be a single path
 
254
   the new node, allocated in RESULT_POOL.  NAME must be a single path
278
255
   component; it cannot be a slash-separated directory path.
279
 
 
280
 
   Use POOL for all allocations, including to cache the node_revision in
281
 
   PARENT.
282
256
 */
283
 
svn_error_t *svn_fs_fs__dag_open(dag_node_t **child_p,
284
 
                                 dag_node_t *parent,
285
 
                                 const char *name,
286
 
                                 apr_pool_t *pool);
 
257
svn_error_t *
 
258
svn_fs_fs__dag_open(dag_node_t **child_p,
 
259
                    dag_node_t *parent,
 
260
                    const char *name,
 
261
                    apr_pool_t *result_pool,
 
262
                    apr_pool_t *scratch_pool);
287
263
 
288
264
 
289
265
/* Set *ENTRIES_P to a hash table of NODE's entries.  The keys of the
290
266
   table are entry names, and the values are svn_fs_dirent_t's.  The
291
267
   returned table (and its keys and values) is allocated in POOL,
292
 
   which is also used for temporary allocations.  NODE_POOL is used
293
 
   for any allocation of memory that needs to live as long as NODE
294
 
   lives. */
 
268
   which is also used for temporary allocations. */
295
269
svn_error_t *svn_fs_fs__dag_dir_entries(apr_hash_t **entries_p,
296
270
                                        dag_node_t *node,
297
 
                                        apr_pool_t *pool,
298
 
                                        apr_pool_t *node_pool);
 
271
                                        apr_pool_t *pool);
299
272
 
300
273
/* Fetches the NODE's entries and returns a copy of the entry selected
301
274
   by the key value given in NAME and set *DIRENT to a copy of that
302
275
   entry. If such entry was found, the copy will be allocated in POOL.
303
 
   Otherwise, the *DIRENT will be set to NULL. NODE_POOL is used for
304
 
   any allocation of memory that needs to live as long as NODE lives.
 
276
   Otherwise, the *DIRENT will be set to NULL.
305
277
 */
 
278
/* ### This function is currently only called from dag.c. */
306
279
svn_error_t * svn_fs_fs__dag_dir_entry(svn_fs_dirent_t **dirent,
307
280
                                       dag_node_t *node,
308
281
                                       const char* name,
309
 
                                       apr_pool_t *pool,
310
 
                                       apr_pool_t *node_pool);
 
282
                                       apr_pool_t *pool);
311
283
 
312
284
/* Set ENTRY_NAME in NODE to point to ID (with kind KIND), allocating
313
285
   from POOL.  NODE must be a mutable directory.  ID can refer to a
343
315
 
344
316
   TXN_ID is the Subversion transaction under which this occurs.
345
317
 
346
 
   Use POOL for all allocations, including to cache the node_revision in
347
 
   FILE.
 
318
   Use POOL for all allocations.
348
319
 */
349
320
svn_error_t *svn_fs_fs__dag_clone_child(dag_node_t **child_p,
350
321
                                        dag_node_t *parent,
366
337
   If return SVN_ERR_FS_NO_SUCH_ENTRY, then there is no entry NAME in
367
338
   PARENT.
368
339
 
369
 
   Use POOL for all allocations, including to cache the node_revision in
370
 
   FILE.
 
340
   Use POOL for all allocations.
371
341
 */
372
342
svn_error_t *svn_fs_fs__dag_delete(dag_node_t *parent,
373
343
                                   const char *name,
408
378
   not currently have an entry named NAME.  TXN_ID is the Subversion
409
379
   transaction under which this occurs.
410
380
 
411
 
   Use POOL for all allocations, including to cache the node_revision in
412
 
   PARENT.
 
381
   Use POOL for all allocations.
413
382
 */
414
383
svn_error_t *svn_fs_fs__dag_make_dir(dag_node_t **child_p,
415
384
                                     dag_node_t *parent,
428
397
 
429
398
   If FILE is not a file, return SVN_ERR_FS_NOT_FILE.
430
399
 
431
 
   Use POOL for all allocations, including to cache the node_revision in
432
 
   FILE.
 
400
   Use POOL for all allocations.
433
401
 */
434
402
svn_error_t *svn_fs_fs__dag_get_contents(svn_stream_t **contents,
435
403
                                         dag_node_t *file,
436
404
                                         apr_pool_t *pool);
437
405
 
 
406
/* Attempt to fetch the contents of NODE and pass it along with the BATON
 
407
   to the PROCESSOR.   Set *SUCCESS only of the data could be provided
 
408
   and the processor had been called.
 
409
 
 
410
   Use POOL for all allocations.
 
411
 */
 
412
svn_error_t *
 
413
svn_fs_fs__dag_try_process_file_contents(svn_boolean_t *success,
 
414
                                         dag_node_t *node,
 
415
                                         svn_fs_process_contents_func_t processor,
 
416
                                         void* baton,
 
417
                                         apr_pool_t *pool);
 
418
 
438
419
 
439
420
/* Set *STREAM_P to a delta stream that will turn the contents of SOURCE into
440
421
   the contents of TARGET, allocated in POOL.  If SOURCE is null, the empty
441
422
   string will be used.
442
423
 
443
 
   Use POOL for all allocations, including to cache the node_revision in
444
 
   SOURCE and TARGET.
 
424
   Use POOL for all allocations.
445
425
 */
446
426
svn_error_t *
447
427
svn_fs_fs__dag_get_file_delta_stream(svn_txdelta_stream_t **stream_p,
455
435
   Any previous edits on the file will be deleted, and a new edit
456
436
   stream will be constructed.
457
437
 
458
 
   Use POOL for all allocations, including to cache the node_revision in
459
 
   FILE.
 
438
   Use POOL for all allocations.
460
439
 */
461
440
svn_error_t *svn_fs_fs__dag_get_edit_stream(svn_stream_t **contents,
462
441
                                            dag_node_t *file,
482
461
 
483
462
/* Set *LENGTH to the length of the contents of FILE.
484
463
 
485
 
   Use POOL for all allocations, including to cache the node_revision in
486
 
   FILE.
 
464
   Use POOL for all allocations.
487
465
 */
488
466
svn_error_t *svn_fs_fs__dag_file_length(svn_filesize_t *length,
489
467
                                        dag_node_t *file,
495
473
   If no stored checksum is available, do not calculate the checksum,
496
474
   just put NULL into CHECKSUM.
497
475
 
498
 
   Use POOL for all allocations, including to cache the node_revision in
499
 
   FILE.
 
476
   Use POOL for all allocations.
500
477
 */
501
478
svn_error_t *
502
479
svn_fs_fs__dag_file_checksum(svn_checksum_t **checksum,
512
489
   canonicalized absolute path of the parent directory.  TXN_ID is the
513
490
   Subversion transaction under which this occurs.
514
491
 
515
 
   Use POOL for all allocations, including to cache the node_revision in
516
 
   PARENT.
 
492
   Use POOL for all allocations.
517
493
 */
518
494
svn_error_t *svn_fs_fs__dag_make_file(dag_node_t **child_p,
519
495
                                      dag_node_t *parent,
538
514
 
539
515
   If PRESERVE_HISTORY is false, FROM_PATH and FROM_REV are ignored.
540
516
 
541
 
   Use POOL for all allocations, including to cache the node_revision in
542
 
   FROM_NODE.
 
517
   Use POOL for all allocations.
543
518
 */
544
519
svn_error_t *svn_fs_fs__dag_copy(dag_node_t *to_node,
545
520
                                 const char *entry,
569
544
   may leave us with a slight chance of a false positive, though I
570
545
   don't really see how that would happen in practice.  Nevertheless,
571
546
   it should probably be fixed.
572
 
 
573
 
   Use POOL for all allocations, including to cache the node_revision in NODE1
574
 
   and NODE2.
575
547
 */
576
548
svn_error_t *svn_fs_fs__dag_things_different(svn_boolean_t *props_changed,
577
549
                                             svn_boolean_t *contents_changed,
578
550
                                             dag_node_t *node1,
579
 
                                             dag_node_t *node2,
580
 
                                             apr_pool_t *pool);
 
551
                                             dag_node_t *node2);
581
552
 
582
553
 
583
554
/* Set *REV and *PATH to the copyroot revision and path of node NODE, or
584
555
   to SVN_INVALID_REVNUM and NULL if no copyroot exists.
585
 
   Use POOL for all allocations, including to cache the node_revision in NODE.
586
556
 */
587
557
svn_error_t *svn_fs_fs__dag_get_copyroot(svn_revnum_t *rev,
588
558
                                         const char **path,
589
 
                                         dag_node_t *node,
590
 
                                         apr_pool_t *pool);
 
559
                                         dag_node_t *node);
591
560
 
592
561
/* Set *REV to the copyfrom revision associated with NODE.
593
 
   Use POOL for all allocations, including to cache the node_revision in NODE.
594
562
 */
595
563
svn_error_t *svn_fs_fs__dag_get_copyfrom_rev(svn_revnum_t *rev,
596
 
                                             dag_node_t *node,
597
 
                                             apr_pool_t *pool);
 
564
                                             dag_node_t *node);
598
565
 
599
566
/* Set *PATH to the copyfrom path associated with NODE.
600
 
   Use POOL for all allocations, including to cache the node_revision in NODE.
601
567
 */
602
568
svn_error_t *svn_fs_fs__dag_get_copyfrom_path(const char **path,
603
 
                                              dag_node_t *node,
604
 
                                              apr_pool_t *pool);
 
569
                                              dag_node_t *node);
605
570
 
606
571
/* Update *TARGET so that SOURCE is it's predecessor.
607
572
 */