You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by br...@apache.org on 2015/01/16 15:01:37 UTC
svn commit: r1652409 [5/18] - in /subversion/branches/svn-auth-x509: ./
notes/ subversion/bindings/swig/ subversion/bindings/swig/include/
subversion/bindings/swig/perl/native/ subversion/bindings/swig/perl/native/t/
subversion/bindings/swig/python/lib...
Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/changes.c
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/changes.c?rev=1652409&r1=1652408&r2=1652409&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/changes.c (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/changes.c Fri Jan 16 14:01:35 2015
@@ -79,9 +79,7 @@ typedef struct binary_change_t
/* Relevant parts of the node revision ID of the change.
* Empty, if REV_ID is not "used". */
- svn_fs_x__id_part_t node_id;
- svn_fs_x__id_part_t copy_id;
- svn_fs_x__id_part_t noderev_id;
+ svn_fs_x__id_t noderev_id;
} binary_change_t;
@@ -104,19 +102,19 @@ struct svn_fs_x__changes_t
apr_array_header_t *offsets;
};
-/* Create and return a new container object, allocated in POOL and with
- * and initial capacity of INITIAL_COUNT changes. The PATH and BUILDER
+/* Create and return a new container object, allocated in RESULT_POOL with
+ * an initial capacity of INITIAL_COUNT changes. The PATH and BUILDER
* members must be initialized by the caller afterwards.
*/
static svn_fs_x__changes_t *
changes_create_body(apr_size_t initial_count,
- apr_pool_t *pool)
+ apr_pool_t *result_pool)
{
- svn_fs_x__changes_t *changes = apr_pcalloc(pool, sizeof(*changes));
+ svn_fs_x__changes_t *changes = apr_pcalloc(result_pool, sizeof(*changes));
- changes->changes = apr_array_make(pool, (int)initial_count,
+ changes->changes = apr_array_make(result_pool, (int)initial_count,
sizeof(binary_change_t));
- changes->offsets = apr_array_make(pool, 16, sizeof(int));
+ changes->offsets = apr_array_make(result_pool, 16, sizeof(int));
APR_ARRAY_PUSH(changes->offsets, int) = 0;
return changes;
@@ -124,10 +122,11 @@ changes_create_body(apr_size_t initial_c
svn_fs_x__changes_t *
svn_fs_x__changes_create(apr_size_t initial_count,
- apr_pool_t *pool)
+ apr_pool_t *result_pool)
{
- svn_fs_x__changes_t *changes = changes_create_body(initial_count, pool);
- changes->builder = svn_fs_x__string_table_builder_create(pool);
+ svn_fs_x__changes_t *changes = changes_create_body(initial_count,
+ result_pool);
+ changes->builder = svn_fs_x__string_table_builder_create(result_pool);
return changes;
}
@@ -136,24 +135,25 @@ svn_fs_x__changes_create(apr_size_t init
*/
static svn_error_t *
append_change(svn_fs_x__changes_t *changes,
- change_t *change)
+ svn_fs_x__change_t *change)
{
binary_change_t binary_change = { 0 };
svn_boolean_t is_txn_id;
- svn_fs_path_change2_t *info;
/* CHANGE must be sufficiently complete */
SVN_ERR_ASSERT(change);
SVN_ERR_ASSERT(change->path.data);
+ /* Relevant parts of the revision ID of the change. */
+ binary_change.noderev_id = change->noderev_id;
+
/* define the kind of change and what specific information is present */
- info = &change->info;
- is_txn_id = info->node_rev_id && svn_fs_x__id_is_txn(info->node_rev_id);
- binary_change.flags = (info->text_mod ? CHANGE_TEXT_MOD : 0)
- | (info->prop_mod ? CHANGE_PROP_MOD : 0)
+ is_txn_id = svn_fs_x__is_txn(binary_change.noderev_id.change_set);
+ binary_change.flags = (change->text_mod ? CHANGE_TEXT_MOD : 0)
+ | (change->prop_mod ? CHANGE_PROP_MOD : 0)
| (is_txn_id ? CHANGE_TXN_NODE : 0)
- | ((int)info->change_kind << CHANGE_KIND_SHIFT)
- | ((int)info->node_kind << CHANGE_NODE_SHIFT);
+ | ((int)change->change_kind << CHANGE_KIND_SHIFT)
+ | ((int)change->node_kind << CHANGE_NODE_SHIFT);
/* Path of the change. */
binary_change.path
@@ -162,12 +162,12 @@ append_change(svn_fs_x__changes_t *chang
change->path.len);
/* copy-from information, if presence is indicated by FLAGS */
- if (SVN_IS_VALID_REVNUM(info->copyfrom_rev))
+ if (SVN_IS_VALID_REVNUM(change->copyfrom_rev))
{
- binary_change.copyfrom_rev = info->copyfrom_rev;
+ binary_change.copyfrom_rev = change->copyfrom_rev;
binary_change.copyfrom_path
= svn_fs_x__string_table_builder_add(changes->builder,
- info->copyfrom_path,
+ change->copyfrom_path,
0);
}
else
@@ -176,19 +176,6 @@ append_change(svn_fs_x__changes_t *chang
binary_change.copyfrom_path = 0;
}
- /* Relevant parts of the revision ID of the change. */
- if (info->node_rev_id)
- {
- binary_change.node_id = *svn_fs_x__id_node_id(info->node_rev_id);
- binary_change.copy_id = *svn_fs_x__id_copy_id(info->node_rev_id);
- binary_change.noderev_id = *svn_fs_x__id_noderev_id(info->node_rev_id);
- }
- else
- {
- binary_change.noderev_id.number = 0;
- binary_change.noderev_id.change_set = SVN_FS_X__INVALID_CHANGE_SET;
- }
-
APR_ARRAY_PUSH(changes->changes, binary_change_t) = binary_change;
return SVN_NO_ERROR;
@@ -207,7 +194,7 @@ svn_fs_x__changes_append_list(apr_size_t
/* simply append the list and all changes */
for (i = 0; i < list->nelts; ++i)
- append_change(changes, APR_ARRAY_IDX(list, i, change_t *));
+ append_change(changes, APR_ARRAY_IDX(list, i, svn_fs_x__change_t *));
/* terminate the list by storing the next changes offset */
APR_ARRAY_PUSH(changes->offsets, int) = changes->changes->nelts;
@@ -259,44 +246,40 @@ svn_fs_x__changes_get_list(apr_array_hea
last = APR_ARRAY_IDX(changes->offsets, (int)idx + 1, int);
/* construct result */
- *list = apr_array_make(pool, last - first, sizeof(change_t*));
+ *list = apr_array_make(pool, last - first, sizeof(svn_fs_x__change_t*));
for (i = first; i < last; ++i)
{
const binary_change_t *binary_change
= &APR_ARRAY_IDX(changes->changes, i, binary_change_t);
- /* convert BINARY_CHANGE into a standard FSX change_t */
- change_t *change = apr_pcalloc(pool, sizeof(*change));
- svn_fs_path_change2_t *info = &change->info;
+ /* convert BINARY_CHANGE into a standard FSX svn_fs_x__change_t */
+ svn_fs_x__change_t *change = apr_pcalloc(pool, sizeof(*change));
change->path.data = svn_fs_x__string_table_get(changes->paths,
binary_change->path,
&change->path.len,
pool);
if (binary_change->noderev_id.change_set != SVN_FS_X__INVALID_CHANGE_SET)
- info->node_rev_id = svn_fs_x__id_create(&binary_change->node_id,
- &binary_change->copy_id,
- &binary_change->noderev_id,
- pool);
+ change->noderev_id = binary_change->noderev_id;
- info->change_kind = (svn_fs_path_change_kind_t)
+ change->change_kind = (svn_fs_path_change_kind_t)
((binary_change->flags & CHANGE_KIND_MASK) >> CHANGE_KIND_SHIFT);
- info->text_mod = (binary_change->flags & CHANGE_TEXT_MOD) != 0;
- info->prop_mod = (binary_change->flags & CHANGE_PROP_MOD) != 0;
- info->node_kind = (svn_node_kind_t)
+ change->text_mod = (binary_change->flags & CHANGE_TEXT_MOD) != 0;
+ change->prop_mod = (binary_change->flags & CHANGE_PROP_MOD) != 0;
+ change->node_kind = (svn_node_kind_t)
((binary_change->flags & CHANGE_NODE_MASK) >> CHANGE_NODE_SHIFT);
- info->copyfrom_rev = binary_change->copyfrom_rev;
- info->copyfrom_known = TRUE;
+ change->copyfrom_rev = binary_change->copyfrom_rev;
+ change->copyfrom_known = TRUE;
if (SVN_IS_VALID_REVNUM(binary_change->copyfrom_rev))
- info->copyfrom_path
+ change->copyfrom_path
= svn_fs_x__string_table_get(changes->paths,
binary_change->copyfrom_path,
NULL,
pool);
/* add it to the result */
- APR_ARRAY_PUSH(*list, change_t*) = change;
+ APR_ARRAY_PUSH(*list, svn_fs_x__change_t*) = change;
}
return SVN_NO_ERROR;
@@ -305,16 +288,16 @@ svn_fs_x__changes_get_list(apr_array_hea
svn_error_t *
svn_fs_x__write_changes_container(svn_stream_t *stream,
const svn_fs_x__changes_t *changes,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
int i;
string_table_t *paths = changes->paths
? changes->paths
: svn_fs_x__string_table_create(changes->builder,
- pool);
+ scratch_pool);
- svn_packed__data_root_t *root = svn_packed__data_create_root(pool);
+ svn_packed__data_root_t *root = svn_packed__data_create_root(scratch_pool);
/* one top-level stream for each array */
svn_packed__int_stream_t *offsets_stream
@@ -330,11 +313,7 @@ svn_fs_x__write_changes_container(svn_st
svn_packed__create_int_substream(changes_stream, TRUE, FALSE);
svn_packed__create_int_substream(changes_stream, TRUE, TRUE);
svn_packed__create_int_substream(changes_stream, TRUE, FALSE);
- svn_packed__create_int_substream(changes_stream, TRUE, TRUE);
- svn_packed__create_int_substream(changes_stream, TRUE, FALSE);
- svn_packed__create_int_substream(changes_stream, TRUE, TRUE);
- svn_packed__create_int_substream(changes_stream, TRUE, FALSE);
-
+
/* serialize offsets array */
for (i = 0; i < changes->offsets->nelts; ++i)
svn_packed__add_uint(offsets_stream,
@@ -352,17 +331,13 @@ svn_fs_x__write_changes_container(svn_st
svn_packed__add_int(changes_stream, change->copyfrom_rev);
svn_packed__add_uint(changes_stream, change->copyfrom_path);
- svn_packed__add_int(changes_stream, change->node_id.change_set);
- svn_packed__add_uint(changes_stream, change->node_id.number);
- svn_packed__add_int(changes_stream, change->copy_id.change_set);
- svn_packed__add_uint(changes_stream, change->copy_id.number);
svn_packed__add_int(changes_stream, change->noderev_id.change_set);
svn_packed__add_uint(changes_stream, change->noderev_id.number);
}
/* write to disk */
- SVN_ERR(svn_fs_x__write_string_table(stream, paths, pool));
- SVN_ERR(svn_packed__data_write(stream, root, pool));
+ SVN_ERR(svn_fs_x__write_string_table(stream, paths, scratch_pool));
+ SVN_ERR(svn_packed__data_write(stream, root, scratch_pool));
return SVN_NO_ERROR;
}
@@ -412,10 +387,6 @@ svn_fs_x__read_changes_container(svn_fs_
change.copyfrom_rev = (svn_revnum_t)svn_packed__get_int(changes_stream);
change.copyfrom_path = (apr_size_t)svn_packed__get_uint(changes_stream);
- change.node_id.change_set = svn_packed__get_int(changes_stream);
- change.node_id.number = svn_packed__get_uint(changes_stream);
- change.copy_id.change_set = svn_packed__get_int(changes_stream);
- change.copy_id.number = svn_packed__get_uint(changes_stream);
change.noderev_id.change_set = svn_packed__get_int(changes_stream);
change.noderev_id.number = svn_packed__get_uint(changes_stream);
@@ -525,43 +496,38 @@ svn_fs_x__changes_get_list_func(void **o
last = offsets[idx+1];
/* construct result */
- list = apr_array_make(pool, last - first, sizeof(change_t*));
+ list = apr_array_make(pool, last - first, sizeof(svn_fs_x__change_t*));
for (i = first; i < last; ++i)
{
const binary_change_t *binary_change = &changes[i];
- /* convert BINARY_CHANGE into a standard FSX change_t */
- change_t *change = apr_pcalloc(pool, sizeof(*change));
- svn_fs_path_change2_t *info = &change->info;
+ /* convert BINARY_CHANGE into a standard FSX svn_fs_x__change_t */
+ svn_fs_x__change_t *change = apr_pcalloc(pool, sizeof(*change));
change->path.data
= svn_fs_x__string_table_get_func(paths, binary_change->path,
&change->path.len, pool);
- if (binary_change->noderev_id.change_set != SVN_FS_X__INVALID_CHANGE_SET)
- info->node_rev_id = svn_fs_x__id_create(&binary_change->node_id,
- &binary_change->copy_id,
- &binary_change->noderev_id,
- pool);
+ change->noderev_id = binary_change->noderev_id;
- info->change_kind = (svn_fs_path_change_kind_t)
+ change->change_kind = (svn_fs_path_change_kind_t)
((binary_change->flags & CHANGE_KIND_MASK) >> CHANGE_KIND_SHIFT);
- info->text_mod = (binary_change->flags & CHANGE_TEXT_MOD) != 0;
- info->prop_mod = (binary_change->flags & CHANGE_PROP_MOD) != 0;
- info->node_kind = (svn_node_kind_t)
+ change->text_mod = (binary_change->flags & CHANGE_TEXT_MOD) != 0;
+ change->prop_mod = (binary_change->flags & CHANGE_PROP_MOD) != 0;
+ change->node_kind = (svn_node_kind_t)
((binary_change->flags & CHANGE_NODE_MASK) >> CHANGE_NODE_SHIFT);
- info->copyfrom_rev = binary_change->copyfrom_rev;
- info->copyfrom_known = TRUE;
+ change->copyfrom_rev = binary_change->copyfrom_rev;
+ change->copyfrom_known = TRUE;
if (SVN_IS_VALID_REVNUM(binary_change->copyfrom_rev))
- info->copyfrom_path
+ change->copyfrom_path
= svn_fs_x__string_table_get_func(paths,
binary_change->copyfrom_path,
NULL,
pool);
/* add it to the result */
- APR_ARRAY_PUSH(list, change_t*) = change;
+ APR_ARRAY_PUSH(list, svn_fs_x__change_t*) = change;
}
*out = list;
Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/changes.h
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/changes.h?rev=1652409&r1=1652408&r2=1652409&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/changes.h (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/changes.h Fri Jan 16 14:01:35 2015
@@ -32,25 +32,27 @@
*
* In its serialized form, the svn_fs_x__changes_t container extracts most
* of that redundancy and the run-time representation is also much smaller
- * than sum of the respective change_t* arrays.
+ * than sum of the respective svn_fs_x__change_t* arrays.
*
* As with other containers, this one has two modes: 'construction', in
* which you may add data to it, and 'getter' in which there is only r/o
* access to the data.
*/
-/* An opaque collection of change lists (apr_array_header_t * of change_t*).
+/* An opaque collection of change lists (apr_array_header_t * of
+ * svn_fs_x__change_t *).
*/
typedef struct svn_fs_x__changes_t svn_fs_x__changes_t;
/* Create and populate changes containers. */
/* Create and return a new changes container with an initial capacity of
- * INITIAL_COUNT change_t objects. Allocate the result in POOL.
+ * INITIAL_COUNT svn_fs_x__change_t objects.
+ * Allocate the result in RESULT_POOL.
*/
svn_fs_x__changes_t *
svn_fs_x__changes_create(apr_size_t initial_count,
- apr_pool_t *pool);
+ apr_pool_t *result_pool);
/* Start a new change list CHANGES (implicitly terminating the previous one)
* and return its index in *LIST_INDEX. Append all changes from LIST to
@@ -80,13 +82,13 @@ svn_fs_x__changes_get_list(apr_array_hea
/* I/O interface. */
-/* Write a serialized representation of CHANGES to STREAM. Use POOL for
- * temporary allocations.
+/* Write a serialized representation of CHANGES to STREAM.
+ * Use SCRATCH_POOL for temporary allocations.
*/
svn_error_t *
svn_fs_x__write_changes_container(svn_stream_t *stream,
const svn_fs_x__changes_t *changes,
- apr_pool_t *pool);
+ apr_pool_t *scratch_pool);
/* Read a changes container from its serialized representation in STREAM.
* Allocate the result in RESULT_POOL and return it in *CHANGES_P. Use
Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.c
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.c?rev=1652409&r1=1652408&r2=1652409&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.c (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.c Fri Jan 16 14:01:35 2015
@@ -31,7 +31,7 @@
#include "dag.h"
#include "fs.h"
#include "fs_x.h"
-#include "id.h"
+#include "fs_id.h"
#include "cached_data.h"
#include "transaction.h"
@@ -50,14 +50,14 @@ struct dag_node_t
/* The filesystem this dag node came from. */
svn_fs_t *fs;
- /* The node revision ID for this dag node, allocated in POOL. */
- svn_fs_id_t *id;
+ /* The node revision ID for this dag node. */
+ svn_fs_x__id_t id;
/* In the special case that this node is the root of a transaction
that has not yet been modified, the node revision ID for this dag
node's predecessor; otherwise NULL. (Used in
svn_fs_node_created_rev.) */
- const svn_fs_id_t *fresh_root_predecessor_id;
+ svn_fs_x__id_t fresh_root_predecessor_id;
/* The node's type (file, dir, etc.) */
svn_node_kind_t kind;
@@ -69,7 +69,7 @@ struct dag_node_t
this yourself, but you're probably better off just calling
`get_node_revision' and `set_node_revision', which take care of
things for you. */
- node_revision_t *node_revision;
+ svn_fs_x__noderev_t *node_revision;
/* The pool to allocate NODE_REVISION in. */
apr_pool_t *node_pool;
@@ -81,16 +81,16 @@ struct dag_node_t
/* Trivial helper/accessor functions. */
-svn_node_kind_t svn_fs_x__dag_node_kind(dag_node_t *node)
+svn_node_kind_t
+svn_fs_x__dag_node_kind(dag_node_t *node)
{
return node->kind;
}
-
-const svn_fs_id_t *
+const svn_fs_x__id_t *
svn_fs_x__dag_get_id(const dag_node_t *node)
{
- return node->id;
+ return &node->id;
}
@@ -108,35 +108,32 @@ svn_fs_x__dag_get_fs(dag_node_t *node)
}
void
-svn_fs_x__dag_set_fs(dag_node_t *node, svn_fs_t *fs)
+svn_fs_x__dag_set_fs(dag_node_t *node,
+ svn_fs_t *fs)
{
node->fs = fs;
}
-/* Dup NODEREV and all associated data into POOL.
+/* Dup NODEREV and all associated data into RESULT_POOL.
Leaves the id and is_fresh_txn_root fields as zero bytes. */
-static node_revision_t *
-copy_node_revision(node_revision_t *noderev,
- apr_pool_t *pool)
+static svn_fs_x__noderev_t *
+copy_node_revision(svn_fs_x__noderev_t *noderev,
+ apr_pool_t *result_pool)
{
- node_revision_t *nr = apr_pcalloc(pool, sizeof(*nr));
- nr->kind = noderev->kind;
- if (noderev->predecessor_id)
- nr->predecessor_id = svn_fs_x__id_copy(noderev->predecessor_id, pool);
- nr->predecessor_count = noderev->predecessor_count;
+ svn_fs_x__noderev_t *nr = apr_pmemdup(result_pool, noderev,
+ sizeof(*noderev));
+
if (noderev->copyfrom_path)
- nr->copyfrom_path = apr_pstrdup(pool, noderev->copyfrom_path);
- nr->copyfrom_rev = noderev->copyfrom_rev;
- nr->copyroot_path = apr_pstrdup(pool, noderev->copyroot_path);
- nr->copyroot_rev = noderev->copyroot_rev;
- nr->data_rep = svn_fs_x__rep_copy(noderev->data_rep, pool);
- nr->prop_rep = svn_fs_x__rep_copy(noderev->prop_rep, pool);
- nr->mergeinfo_count = noderev->mergeinfo_count;
- nr->has_mergeinfo = noderev->has_mergeinfo;
+ nr->copyfrom_path = apr_pstrdup(result_pool, noderev->copyfrom_path);
+
+ nr->copyroot_path = apr_pstrdup(result_pool, noderev->copyroot_path);
+ nr->data_rep = svn_fs_x__rep_copy(noderev->data_rep, result_pool);
+ nr->prop_rep = svn_fs_x__rep_copy(noderev->prop_rep, result_pool);
if (noderev->created_path)
- nr->created_path = apr_pstrdup(pool, noderev->created_path);
+ nr->created_path = apr_pstrdup(result_pool, noderev->created_path);
+
return nr;
}
@@ -153,18 +150,17 @@ copy_node_revision(node_revision_t *node
changes that never got committed. It's probably best not to change
the structure at all. */
static svn_error_t *
-get_node_revision(node_revision_t **noderev_p,
+get_node_revision(svn_fs_x__noderev_t **noderev_p,
dag_node_t *node)
{
/* If we've already got a copy, there's no need to read it in. */
if (! node->node_revision)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
apr_pool_t *scratch_pool = svn_pool_create(node->node_pool);
- SVN_ERR(svn_fs_x__get_node_revision(&noderev, node->fs,
- node->id, node->node_pool,
- scratch_pool));
+ SVN_ERR(svn_fs_x__get_node_revision(&noderev, node->fs, &node->id,
+ node->node_pool, scratch_pool));
node->node_revision = noderev;
svn_pool_destroy(scratch_pool);
}
@@ -174,39 +170,97 @@ get_node_revision(node_revision_t **node
return SVN_NO_ERROR;
}
+/* Return the node revision ID of NODE. The value returned is shared
+ with NODE, and will be deallocated when NODE is. */
+svn_error_t *
+svn_fs_x__dag_get_node_id(svn_fs_x__id_t *node_id,
+ dag_node_t *node)
+{
+ svn_fs_x__noderev_t *noderev;
+ SVN_ERR(get_node_revision(&noderev, node));
+
+ *node_id = noderev->node_id;
+ return SVN_NO_ERROR;
+}
+
+/* Return the node revision ID of NODE. The value returned is shared
+ with NODE, and will be deallocated when NODE is. */
+svn_error_t *
+svn_fs_x__dag_get_copy_id(svn_fs_x__id_t *copy_id,
+ dag_node_t *node)
+{
+ svn_fs_x__noderev_t *noderev;
+ SVN_ERR(get_node_revision(&noderev, node));
+
+ *copy_id = noderev->copy_id;
+ return SVN_NO_ERROR;
+}
+
+/* Return the node ID of NODE. The value returned is shared with NODE,
+ and will be deallocated when NODE is. */
+svn_error_t *
+svn_fs_x__dag_related_node(svn_boolean_t *same,
+ dag_node_t *lhs,
+ dag_node_t *rhs)
+{
+ svn_fs_x__id_t lhs_node, rhs_node;
+
+ SVN_ERR(svn_fs_x__dag_get_node_id(&lhs_node, lhs));
+ SVN_ERR(svn_fs_x__dag_get_node_id(&rhs_node, rhs));
+ *same = svn_fs_x__id_eq(&lhs_node, &rhs_node);
+
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_fs_x__dag_same_line_of_history(svn_boolean_t *same,
+ dag_node_t *lhs,
+ dag_node_t *rhs)
+{
+ svn_fs_x__noderev_t *lhs_noderev, *rhs_noderev;
+
+ SVN_ERR(get_node_revision(&lhs_noderev, lhs));
+ SVN_ERR(get_node_revision(&rhs_noderev, rhs));
-svn_boolean_t svn_fs_x__dag_check_mutable(const dag_node_t *node)
+ *same = svn_fs_x__id_eq(&lhs_noderev->node_id, &rhs_noderev->node_id)
+ && svn_fs_x__id_eq(&lhs_noderev->copy_id, &rhs_noderev->copy_id);
+
+ return SVN_NO_ERROR;
+}
+
+svn_boolean_t
+svn_fs_x__dag_check_mutable(const dag_node_t *node)
{
- return svn_fs_x__id_is_txn(svn_fs_x__dag_get_id(node));
+ return svn_fs_x__is_txn(svn_fs_x__dag_get_id(node)->change_set);
}
svn_error_t *
svn_fs_x__dag_get_node(dag_node_t **node,
svn_fs_t *fs,
- const svn_fs_id_t *id,
- apr_pool_t *pool)
+ const svn_fs_x__id_t *id,
+ apr_pool_t *result_pool)
{
dag_node_t *new_node;
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
/* Construct the node. */
- new_node = apr_pcalloc(pool, sizeof(*new_node));
+ new_node = apr_pcalloc(result_pool, sizeof(*new_node));
new_node->fs = fs;
- new_node->id = svn_fs_x__id_copy(id, pool);
+ new_node->id = *id;
/* Grab the contents so we can inspect the node's kind and created path. */
- new_node->node_pool = pool;
+ new_node->node_pool = result_pool;
SVN_ERR(get_node_revision(&noderev, new_node));
/* Initialize the KIND and CREATED_PATH attributes */
new_node->kind = noderev->kind;
- new_node->created_path = apr_pstrdup(pool, noderev->created_path);
+ new_node->created_path = apr_pstrdup(result_pool, noderev->created_path);
if (noderev->is_fresh_txn_root)
new_node->fresh_root_predecessor_id = noderev->predecessor_id;
else
- new_node->fresh_root_predecessor_id = NULL;
+ svn_fs_x__id_reset(&new_node->fresh_root_predecessor_id);
/* Return a fresh new node */
*node = new_node;
@@ -214,32 +268,31 @@ svn_fs_x__dag_get_node(dag_node_t **node
}
-svn_error_t *
-svn_fs_x__dag_get_revision(svn_revnum_t *rev,
- dag_node_t *node,
- apr_pool_t *pool)
+svn_revnum_t
+svn_fs_x__dag_get_revision(const dag_node_t *node)
{
/* In the special case that this is an unmodified transaction root,
we need to actually get the revision of the noderev's predecessor
(the revision root); see Issue #2608. */
- const svn_fs_id_t *correct_id = node->fresh_root_predecessor_id
- ? node->fresh_root_predecessor_id : node->id;
+ const svn_fs_x__id_t *correct_id
+ = svn_fs_x__id_used(&node->fresh_root_predecessor_id)
+ ? &node->fresh_root_predecessor_id
+ : &node->id;
/* Look up the committed revision from the Node-ID. */
- *rev = svn_fs_x__id_rev(correct_id);
-
- return SVN_NO_ERROR;
+ return svn_fs_x__get_revnum(correct_id->change_set);
}
svn_error_t *
-svn_fs_x__dag_get_predecessor_id(const svn_fs_id_t **id_p,
+svn_fs_x__dag_get_predecessor_id(svn_fs_x__id_t *id_p,
dag_node_t *node)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
SVN_ERR(get_node_revision(&noderev, node));
*id_p = noderev->predecessor_id;
+
return SVN_NO_ERROR;
}
@@ -248,7 +301,7 @@ svn_error_t *
svn_fs_x__dag_get_predecessor_count(int *count,
dag_node_t *node)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
SVN_ERR(get_node_revision(&noderev, node));
*count = noderev->predecessor_count;
@@ -259,7 +312,7 @@ svn_error_t *
svn_fs_x__dag_get_mergeinfo_count(apr_int64_t *count,
dag_node_t *node)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
SVN_ERR(get_node_revision(&noderev, node));
*count = noderev->mergeinfo_count;
@@ -270,7 +323,7 @@ svn_error_t *
svn_fs_x__dag_has_mergeinfo(svn_boolean_t *has_mergeinfo,
dag_node_t *node)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
SVN_ERR(get_node_revision(&noderev, node));
*has_mergeinfo = noderev->has_mergeinfo;
@@ -281,7 +334,7 @@ svn_error_t *
svn_fs_x__dag_has_descendants_with_mergeinfo(svn_boolean_t *do_they,
dag_node_t *node)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
if (node->kind != svn_node_dir)
{
@@ -304,28 +357,36 @@ svn_fs_x__dag_has_descendants_with_merge
/* Some of these are helpers for functions outside this section. */
-/* Set *ID_P to the node-id for entry NAME in PARENT. If no such
- entry, set *ID_P to NULL but do not error. The node-id is
- allocated in POOL. */
+/* Set *ID_P to the noderev-id for entry NAME in PARENT. If no such
+ entry, set *ID_P to NULL but do not error. */
static svn_error_t *
-dir_entry_id_from_node(const svn_fs_id_t **id_p,
+dir_entry_id_from_node(svn_fs_x__id_t *id_p,
dag_node_t *parent,
const char *name,
- apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
- svn_fs_dirent_t *dirent;
+ svn_fs_x__dirent_t *dirent;
+ svn_fs_x__noderev_t *noderev;
- SVN_ERR(svn_fs_x__dag_dir_entry(&dirent, parent, name, result_pool,
- scratch_pool));
- *id_p = dirent ? dirent->id : NULL;
+ SVN_ERR(get_node_revision(&noderev, parent));
+ if (noderev->kind != svn_node_dir)
+ return svn_error_create(SVN_ERR_FS_NOT_DIRECTORY, NULL,
+ _("Can't get entries of non-directory"));
+
+ /* Get a dirent hash for this directory. */
+ SVN_ERR(svn_fs_x__rep_contents_dir_entry(&dirent, parent->fs, noderev,
+ name, scratch_pool, scratch_pool));
+ if (dirent)
+ *id_p = dirent->id;
+ else
+ svn_fs_x__id_reset(id_p);
return SVN_NO_ERROR;
}
/* Add or set in PARENT a directory entry NAME pointing to ID.
- Allocations are done in POOL.
+ Temporary allocations are done in SCRATCH_POOL.
Assumptions:
- PARENT is a mutable directory.
@@ -335,19 +396,19 @@ dir_entry_id_from_node(const svn_fs_id_t
static svn_error_t *
set_entry(dag_node_t *parent,
const char *name,
- const svn_fs_id_t *id,
+ const svn_fs_x__id_t *id,
svn_node_kind_t kind,
svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- node_revision_t *parent_noderev;
+ svn_fs_x__noderev_t *parent_noderev;
/* Get the parent's node-revision. */
SVN_ERR(get_node_revision(&parent_noderev, parent));
/* Set the new entry. */
return svn_fs_x__set_entry(parent->fs, txn_id, parent_noderev, name, id,
- kind, pool);
+ kind, scratch_pool);
}
@@ -367,8 +428,7 @@ make_entry(dag_node_t **child_p,
svn_fs_x__txn_id_t txn_id,
apr_pool_t *pool)
{
- const svn_fs_id_t *new_node_id;
- node_revision_t new_noderev, *parent_noderev;
+ svn_fs_x__noderev_t new_noderev, *parent_noderev;
/* Make sure that NAME is a single path component. */
if (! svn_path_is_single_path_component(name))
@@ -399,20 +459,20 @@ make_entry(dag_node_t **child_p,
new_noderev.copyroot_rev = parent_noderev->copyroot_rev;
new_noderev.copyfrom_rev = SVN_INVALID_REVNUM;
new_noderev.copyfrom_path = NULL;
+ svn_fs_x__id_reset(&new_noderev.predecessor_id);
SVN_ERR(svn_fs_x__create_node
- (&new_node_id, svn_fs_x__dag_get_fs(parent), &new_noderev,
- svn_fs_x__id_copy_id(svn_fs_x__dag_get_id(parent)),
- txn_id, pool));
+ (svn_fs_x__dag_get_fs(parent), &new_noderev,
+ &parent_noderev->copy_id, txn_id, pool));
/* Create a new dag_node_t for our new node */
SVN_ERR(svn_fs_x__dag_get_node(child_p, svn_fs_x__dag_get_fs(parent),
- new_node_id, pool));
+ &new_noderev.noderev_id, pool));
/* We can safely call set_entry because we already know that
PARENT is mutable, and we just created CHILD, so we know it has
no ancestors (therefore, PARENT cannot be an ancestor of CHILD) */
- return set_entry(parent, name, svn_fs_x__dag_get_id(*child_p),
+ return set_entry(parent, name, &new_noderev.noderev_id,
new_noderev.kind, txn_id, pool);
}
@@ -422,7 +482,7 @@ svn_fs_x__dag_dir_entries(apr_array_head
dag_node_t *node,
apr_pool_t *pool)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
SVN_ERR(get_node_revision(&noderev, node));
@@ -433,33 +493,14 @@ svn_fs_x__dag_dir_entries(apr_array_head
return svn_fs_x__rep_contents_dir(entries, node->fs, noderev, pool, pool);
}
-svn_error_t *
-svn_fs_x__dag_dir_entry(svn_fs_dirent_t **dirent,
- dag_node_t *node,
- const char* name,
- apr_pool_t *result_pool,
- apr_pool_t *scratch_pool)
-{
- node_revision_t *noderev;
- SVN_ERR(get_node_revision(&noderev, node));
-
- if (noderev->kind != svn_node_dir)
- return svn_error_create(SVN_ERR_FS_NOT_DIRECTORY, NULL,
- _("Can't get entries of non-directory"));
-
- /* Get a dirent hash for this directory. */
- return svn_fs_x__rep_contents_dir_entry(dirent, node->fs, noderev, name,
- result_pool, scratch_pool);
-}
-
svn_error_t *
svn_fs_x__dag_set_entry(dag_node_t *node,
const char *entry_name,
- const svn_fs_id_t *id,
+ const svn_fs_x__id_t *id,
svn_node_kind_t kind,
svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
/* Check it's a directory. */
if (node->kind != svn_node_dir)
@@ -473,7 +514,7 @@ svn_fs_x__dag_set_entry(dag_node_t *node
(SVN_ERR_FS_NOT_MUTABLE, NULL,
_("Attempted to set entry in immutable node"));
- return set_entry(node, entry_name, id, kind, txn_id, pool);
+ return set_entry(node, entry_name, id, kind, txn_id, scratch_pool);
}
@@ -485,7 +526,7 @@ svn_fs_x__dag_get_proplist(apr_hash_t **
dag_node_t *node,
apr_pool_t *pool)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
apr_hash_t *proplist = NULL;
SVN_ERR(get_node_revision(&noderev, node));
@@ -501,14 +542,14 @@ svn_fs_x__dag_get_proplist(apr_hash_t **
svn_error_t *
svn_fs_x__dag_set_proplist(dag_node_t *node,
apr_hash_t *proplist,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
/* Sanity check: this node better be mutable! */
if (! svn_fs_x__dag_check_mutable(node))
{
- svn_string_t *idstr = svn_fs_x__id_unparse(node->id, pool);
+ svn_string_t *idstr = svn_fs_x__id_unparse(&node->id, scratch_pool);
return svn_error_createf
(SVN_ERR_FS_NOT_MUTABLE, NULL,
"Can't set proplist on *immutable* node-revision %s",
@@ -519,21 +560,21 @@ svn_fs_x__dag_set_proplist(dag_node_t *n
SVN_ERR(get_node_revision(&noderev, node));
/* Set the new proplist. */
- return svn_fs_x__set_proplist(node->fs, noderev, proplist, pool);
+ return svn_fs_x__set_proplist(node->fs, noderev, proplist, scratch_pool);
}
svn_error_t *
svn_fs_x__dag_increment_mergeinfo_count(dag_node_t *node,
apr_int64_t increment,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
/* Sanity check: this node better be mutable! */
if (! svn_fs_x__dag_check_mutable(node))
{
- svn_string_t *idstr = svn_fs_x__id_unparse(node->id, pool);
+ svn_string_t *idstr = svn_fs_x__id_unparse(&node->id, scratch_pool);
return svn_error_createf
(SVN_ERR_FS_NOT_MUTABLE, NULL,
"Can't increment mergeinfo count on *immutable* node-revision %s",
@@ -549,10 +590,10 @@ svn_fs_x__dag_increment_mergeinfo_count(
noderev->mergeinfo_count += increment;
if (noderev->mergeinfo_count < 0)
{
- svn_string_t *idstr = svn_fs_x__id_unparse(node->id, pool);
+ svn_string_t *idstr = svn_fs_x__id_unparse(&node->id, scratch_pool);
return svn_error_createf
(SVN_ERR_FS_CORRUPT, NULL,
- apr_psprintf(pool,
+ apr_psprintf(scratch_pool,
_("Can't increment mergeinfo count on node-revision %%s "
"to negative value %%%s"),
APR_INT64_T_FMT),
@@ -560,10 +601,10 @@ svn_fs_x__dag_increment_mergeinfo_count(
}
if (noderev->mergeinfo_count > 1 && noderev->kind == svn_node_file)
{
- svn_string_t *idstr = svn_fs_x__id_unparse(node->id, pool);
+ svn_string_t *idstr = svn_fs_x__id_unparse(&node->id, scratch_pool);
return svn_error_createf
(SVN_ERR_FS_CORRUPT, NULL,
- apr_psprintf(pool,
+ apr_psprintf(scratch_pool,
_("Can't increment mergeinfo count on *file* "
"node-revision %%s to %%%s (> 1)"),
APR_INT64_T_FMT),
@@ -571,21 +612,20 @@ svn_fs_x__dag_increment_mergeinfo_count(
}
/* Flush it out. */
- return svn_fs_x__put_node_revision(node->fs, noderev->id,
- noderev, FALSE, pool);
+ return svn_fs_x__put_node_revision(node->fs, noderev, FALSE, scratch_pool);
}
svn_error_t *
svn_fs_x__dag_set_has_mergeinfo(dag_node_t *node,
- svn_boolean_t has_mergeinfo,
- apr_pool_t *pool)
+ svn_boolean_t has_mergeinfo,
+ apr_pool_t *scratch_pool)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
/* Sanity check: this node better be mutable! */
if (! svn_fs_x__dag_check_mutable(node))
{
- svn_string_t *idstr = svn_fs_x__id_unparse(node->id, pool);
+ svn_string_t *idstr = svn_fs_x__id_unparse(&node->id, scratch_pool);
return svn_error_createf
(SVN_ERR_FS_NOT_MUTABLE, NULL,
"Can't set mergeinfo flag on *immutable* node-revision %s",
@@ -598,8 +638,7 @@ svn_fs_x__dag_set_has_mergeinfo(dag_node
noderev->has_mergeinfo = has_mergeinfo;
/* Flush it out. */
- return svn_fs_x__put_node_revision(node->fs, noderev->id,
- noderev, FALSE, pool);
+ return svn_fs_x__put_node_revision(node->fs, noderev, FALSE, scratch_pool);
}
@@ -616,7 +655,8 @@ svn_fs_x__dag_revision_root(dag_node_t *
/* Construct the node. */
new_node = apr_pcalloc(pool, sizeof(*new_node));
new_node->fs = fs;
- SVN_ERR(svn_fs_x__rev_get_root(&new_node->id, fs, rev, pool, pool));
+ SVN_ERR(svn_fs_x__rev_get_root(&new_node->id, fs, rev, pool));
+ svn_fs_x__id_reset(&new_node->fresh_root_predecessor_id);
/* Grab the contents so we can inspect the node's kind and created path. */
new_node->node_pool = pool;
@@ -624,7 +664,6 @@ svn_fs_x__dag_revision_root(dag_node_t *
/* Initialize the KIND and CREATED_PATH attributes */
new_node->kind = svn_node_dir;
new_node->created_path = "/";
- new_node->fresh_root_predecessor_id = NULL;
/* Return a fresh new node */
*node_p = new_node;
@@ -636,12 +675,12 @@ svn_error_t *
svn_fs_x__dag_txn_root(dag_node_t **node_p,
svn_fs_t *fs,
svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool)
+ apr_pool_t *result_pool)
{
- const svn_fs_id_t *root_id, *ignored;
+ svn_fs_x__id_t root_id;
- SVN_ERR(svn_fs_x__get_txn_ids(&root_id, &ignored, fs, txn_id, pool));
- return svn_fs_x__dag_get_node(node_p, fs, root_id, pool);
+ svn_fs_x__init_txn_root(&root_id, txn_id);
+ return svn_fs_x__dag_get_node(node_p, fs, &root_id, result_pool);
}
@@ -651,10 +690,13 @@ svn_fs_x__dag_txn_base_root(dag_node_t *
svn_fs_x__txn_id_t txn_id,
apr_pool_t *pool)
{
- const svn_fs_id_t *base_root_id, *ignored;
+ svn_fs_x__id_t base_root_id;
+ svn_revnum_t base_rev;
- SVN_ERR(svn_fs_x__get_txn_ids(&ignored, &base_root_id, fs, txn_id, pool));
- return svn_fs_x__dag_get_node(node_p, fs, base_root_id, pool);
+ SVN_ERR(svn_fs_x__get_base_rev(&base_rev, fs, txn_id, pool));
+
+ svn_fs_x__init_rev_root(&base_root_id, base_rev);
+ return svn_fs_x__dag_get_node(node_p, fs, &base_root_id, pool);
}
@@ -663,13 +705,13 @@ svn_fs_x__dag_clone_child(dag_node_t **c
dag_node_t *parent,
const char *parent_path,
const char *name,
- const svn_fs_x__id_part_t *copy_id,
+ const svn_fs_x__id_t *copy_id,
svn_fs_x__txn_id_t txn_id,
svn_boolean_t is_parent_copyroot,
apr_pool_t *pool)
{
dag_node_t *cur_entry; /* parent's current entry named NAME */
- const svn_fs_id_t *new_node_id; /* node id we'll put into NEW_NODE */
+ const svn_fs_x__id_t *new_node_id; /* node id we'll put into NEW_NODE */
svn_fs_t *fs = svn_fs_x__dag_get_fs(parent);
apr_pool_t *subpool = svn_pool_create(pool);
@@ -697,11 +739,11 @@ svn_fs_x__dag_clone_child(dag_node_t **c
if (svn_fs_x__dag_check_mutable(cur_entry))
{
/* This has already been cloned */
- new_node_id = cur_entry->id;
+ new_node_id = svn_fs_x__dag_get_id(cur_entry);
}
else
{
- node_revision_t *noderev, *parent_noderev;
+ svn_fs_x__noderev_t *noderev, *parent_noderev;
/* Go get a fresh NODE-REVISION for current child node. */
SVN_ERR(get_node_revision(&noderev, cur_entry));
@@ -717,13 +759,15 @@ svn_fs_x__dag_clone_child(dag_node_t **c
noderev->copyfrom_path = NULL;
noderev->copyfrom_rev = SVN_INVALID_REVNUM;
- noderev->predecessor_id = svn_fs_x__id_copy(cur_entry->id, pool);
- if (noderev->predecessor_count != -1)
- noderev->predecessor_count++;
+ noderev->predecessor_id = noderev->noderev_id;
+ noderev->predecessor_count++;
noderev->created_path = svn_fspath__join(parent_path, name, pool);
- SVN_ERR(svn_fs_x__create_successor(&new_node_id, fs, cur_entry->id,
- noderev, copy_id, txn_id, pool));
+ if (copy_id == NULL)
+ copy_id = &noderev->copy_id;
+
+ SVN_ERR(svn_fs_x__create_successor(fs, noderev, copy_id, txn_id, pool));
+ new_node_id = &noderev->noderev_id;
/* Replace the ID in the parent's ENTRY list with the ID which
refers to the mutable clone of this child. */
@@ -742,26 +786,13 @@ svn_error_t *
svn_fs_x__dag_clone_root(dag_node_t **root_p,
svn_fs_t *fs,
svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool)
+ apr_pool_t *result_pool)
{
- const svn_fs_id_t *base_root_id, *root_id;
-
- /* Get the node ID's of the root directories of the transaction and
- its base revision. */
- SVN_ERR(svn_fs_x__get_txn_ids(&root_id, &base_root_id, fs, txn_id, pool));
-
- /* Oh, give me a clone...
- (If they're the same, we haven't cloned the transaction's root
- directory yet.) */
- SVN_ERR_ASSERT(!svn_fs_x__id_eq(root_id, base_root_id));
-
- /*
- * (Sung to the tune of "Home, Home on the Range", with thanks to
- * Randall Garrett and Isaac Asimov.)
- */
+ svn_fs_x__id_t root_id;
+ svn_fs_x__init_txn_root(&root_id, txn_id);
/* One way or another, root_id now identifies a cloned root node. */
- return svn_fs_x__dag_get_node(root_p, fs, root_id, pool);
+ return svn_fs_x__dag_get_node(root_p, fs, &root_id, result_pool);
}
@@ -769,12 +800,11 @@ svn_error_t *
svn_fs_x__dag_delete(dag_node_t *parent,
const char *name,
svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- node_revision_t *parent_noderev;
+ svn_fs_x__noderev_t *parent_noderev;
svn_fs_t *fs = parent->fs;
- svn_fs_dirent_t *dirent;
- svn_fs_id_t *id;
+ svn_fs_x__dirent_t *dirent;
apr_pool_t *subpool;
/* Make sure parent is a directory. */
@@ -798,7 +828,7 @@ svn_fs_x__dag_delete(dag_node_t *parent,
/* Get a fresh NODE-REVISION for the parent node. */
SVN_ERR(get_node_revision(&parent_noderev, parent));
- subpool = svn_pool_create(pool);
+ subpool = svn_pool_create(scratch_pool);
/* Search this directory for a dirent with that NAME. */
SVN_ERR(svn_fs_x__rep_contents_dir_entry(&dirent, fs, parent_noderev,
@@ -812,49 +842,26 @@ svn_fs_x__dag_delete(dag_node_t *parent,
(SVN_ERR_FS_NO_SUCH_ENTRY, NULL,
"Delete failed--directory has no entry '%s'", name);
- /* Copy the ID out of the subpool and release the rest of the
- directory listing. */
- id = svn_fs_x__id_copy(dirent->id, pool);
- svn_pool_destroy(subpool);
-
/* If mutable, remove it and any mutable children from db. */
- SVN_ERR(svn_fs_x__dag_delete_if_mutable(parent->fs, id, pool));
+ SVN_ERR(svn_fs_x__dag_delete_if_mutable(parent->fs, &dirent->id,
+ scratch_pool));
+ svn_pool_destroy(subpool);
/* Remove this entry from its parent's entries list. */
return svn_fs_x__set_entry(parent->fs, txn_id, parent_noderev, name,
- NULL, svn_node_unknown, pool);
-}
-
-
-svn_error_t *
-svn_fs_x__dag_remove_node(svn_fs_t *fs,
- const svn_fs_id_t *id,
- apr_pool_t *pool)
-{
- dag_node_t *node;
-
- /* Fetch the node. */
- SVN_ERR(svn_fs_x__dag_get_node(&node, fs, id, pool));
-
- /* If immutable, do nothing and return immediately. */
- if (! svn_fs_x__dag_check_mutable(node))
- return svn_error_createf(SVN_ERR_FS_NOT_MUTABLE, NULL,
- "Attempted removal of immutable node");
-
- /* Delete the node revision. */
- return svn_fs_x__delete_node_revision(fs, id, pool);
+ NULL, svn_node_unknown, scratch_pool);
}
svn_error_t *
svn_fs_x__dag_delete_if_mutable(svn_fs_t *fs,
- const svn_fs_id_t *id,
- apr_pool_t *pool)
+ const svn_fs_x__id_t *id,
+ apr_pool_t *scratch_pool)
{
dag_node_t *node;
/* Get the node. */
- SVN_ERR(svn_fs_x__dag_get_node(&node, fs, id, pool));
+ SVN_ERR(svn_fs_x__dag_get_node(&node, fs, id, scratch_pool));
/* If immutable, do nothing and return immediately. */
if (! svn_fs_x__dag_check_mutable(node))
@@ -865,19 +872,27 @@ svn_fs_x__dag_delete_if_mutable(svn_fs_t
{
apr_array_header_t *entries;
int i;
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
/* Loop over directory entries */
- SVN_ERR(svn_fs_x__dag_dir_entries(&entries, node, pool));
+ SVN_ERR(svn_fs_x__dag_dir_entries(&entries, node, scratch_pool));
if (entries)
for (i = 0; i < entries->nelts; ++i)
- SVN_ERR(svn_fs_x__dag_delete_if_mutable(fs,
- APR_ARRAY_IDX(entries, i, svn_fs_dirent_t *)->id,
- pool));
+ {
+ const svn_fs_x__id_t *noderev_id
+ = &APR_ARRAY_IDX(entries, i, svn_fs_x__dirent_t *)->id;
+
+ svn_pool_clear(iterpool);
+ SVN_ERR(svn_fs_x__dag_delete_if_mutable(fs, noderev_id,
+ scratch_pool));
+ }
+
+ svn_pool_destroy(iterpool);
}
/* ... then delete the node itself, after deleting any mutable
representations and strings it points to. */
- return svn_fs_x__dag_remove_node(fs, id, pool);
+ return svn_fs_x__delete_node_revision(fs, id, scratch_pool);
}
svn_error_t *
@@ -911,7 +926,7 @@ svn_fs_x__dag_get_contents(svn_stream_t
dag_node_t *file,
apr_pool_t *pool)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
svn_stream_t *contents;
/* Make sure our node is a file. */
@@ -939,8 +954,8 @@ svn_fs_x__dag_get_file_delta_stream(svn_
dag_node_t *target,
apr_pool_t *pool)
{
- node_revision_t *src_noderev;
- node_revision_t *tgt_noderev;
+ svn_fs_x__noderev_t *src_noderev;
+ svn_fs_x__noderev_t *tgt_noderev;
/* Make sure our nodes are files. */
if ((source && source->kind != svn_node_file)
@@ -969,7 +984,7 @@ svn_fs_x__dag_try_process_file_contents(
void* baton,
apr_pool_t *pool)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
/* Go get fresh node-revisions for the nodes. */
SVN_ERR(get_node_revision(&noderev, node));
@@ -982,10 +997,9 @@ svn_fs_x__dag_try_process_file_contents(
svn_error_t *
svn_fs_x__dag_file_length(svn_filesize_t *length,
- dag_node_t *file,
- apr_pool_t *pool)
+ dag_node_t *file)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
/* Make sure our node is a file. */
if (file->kind != svn_node_file)
@@ -996,7 +1010,7 @@ svn_fs_x__dag_file_length(svn_filesize_t
/* Go get a fresh node-revision for FILE, and . */
SVN_ERR(get_node_revision(&noderev, file));
- return svn_fs_x__file_length(length, noderev, pool);
+ return svn_fs_x__file_length(length, noderev);
}
@@ -1004,9 +1018,9 @@ svn_error_t *
svn_fs_x__dag_file_checksum(svn_checksum_t **checksum,
dag_node_t *file,
svn_checksum_kind_t kind,
- apr_pool_t *pool)
+ apr_pool_t *result_pool)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
if (file->kind != svn_node_file)
return svn_error_createf
@@ -1015,7 +1029,7 @@ svn_fs_x__dag_file_checksum(svn_checksum
SVN_ERR(get_node_revision(&noderev, file));
- return svn_fs_x__file_checksum(checksum, noderev, kind, pool);
+ return svn_fs_x__file_checksum(checksum, noderev, kind, result_pool);
}
@@ -1024,7 +1038,7 @@ svn_fs_x__dag_get_edit_stream(svn_stream
dag_node_t *file,
apr_pool_t *pool)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
svn_stream_t *ws;
/* Make sure our node is a file. */
@@ -1054,16 +1068,17 @@ svn_fs_x__dag_get_edit_stream(svn_stream
svn_error_t *
svn_fs_x__dag_finalize_edits(dag_node_t *file,
const svn_checksum_t *checksum,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
if (checksum)
{
svn_checksum_t *file_checksum;
SVN_ERR(svn_fs_x__dag_file_checksum(&file_checksum, file,
- checksum->kind, pool));
+ checksum->kind, scratch_pool));
if (!svn_checksum_match(checksum, file_checksum))
- return svn_checksum_mismatch_err(checksum, file_checksum, pool,
+ return svn_checksum_mismatch_err(checksum, file_checksum,
+ scratch_pool,
_("Checksum mismatch for '%s'"),
file->created_path);
}
@@ -1074,30 +1089,38 @@ svn_fs_x__dag_finalize_edits(dag_node_t
dag_node_t *
svn_fs_x__dag_dup(const dag_node_t *node,
- apr_pool_t *pool)
+ apr_pool_t *result_pool)
{
/* Allocate our new node. */
- dag_node_t *new_node = apr_pcalloc(pool, sizeof(*new_node));
+ dag_node_t *new_node = apr_pmemdup(result_pool, node, sizeof(*new_node));
- new_node->fs = node->fs;
- new_node->id = svn_fs_x__id_copy(node->id, pool);
- new_node->kind = node->kind;
- new_node->created_path = apr_pstrdup(pool, node->created_path);
-
- /* Only copy cached node_revision_t for immutable nodes. */
+ /* Only copy cached svn_fs_x__noderev_t for immutable nodes. */
if (node->node_revision && !svn_fs_x__dag_check_mutable(node))
{
- new_node->node_revision = copy_node_revision(node->node_revision, pool);
- new_node->node_revision->id =
- svn_fs_x__id_copy(node->node_revision->id, pool);
- new_node->node_revision->is_fresh_txn_root =
- node->node_revision->is_fresh_txn_root;
+ new_node->node_revision = copy_node_revision(node->node_revision,
+ result_pool);
+ new_node->created_path = new_node->node_revision->created_path;
}
- new_node->node_pool = pool;
+ else
+ {
+ new_node->node_revision = NULL;
+ new_node->created_path = apr_pstrdup(result_pool, node->created_path);
+ }
+
+ new_node->node_pool = result_pool;
return new_node;
}
+dag_node_t *
+svn_fs_x__dag_copy_into_pool(dag_node_t *node,
+ apr_pool_t *result_pool)
+{
+ return (node->node_pool == result_pool
+ ? node
+ : svn_fs_x__dag_dup(node, result_pool));
+}
+
svn_error_t *
svn_fs_x__dag_serialize(void **data,
apr_size_t *data_len,
@@ -1116,20 +1139,20 @@ svn_fs_x__dag_serialize(void **data,
/* for mutable nodes, we will _never_ cache the noderev */
if (node->node_revision && !svn_fs_x__dag_check_mutable(node))
- svn_fs_x__noderev_serialize(context, &node->node_revision);
+ {
+ svn_fs_x__noderev_serialize(context, &node->node_revision);
+ }
else
- svn_temp_serializer__set_null(context,
- (const void * const *)&node->node_revision);
+ {
+ svn_temp_serializer__set_null(context,
+ (const void * const *)&node->node_revision);
+ svn_temp_serializer__add_string(context, &node->created_path);
+ }
/* The deserializer will use its own pool. */
svn_temp_serializer__set_null(context,
(const void * const *)&node->node_pool);
- /* serialize other sub-structures */
- svn_fs_x__id_serialize(context, (const svn_fs_id_t **)&node->id);
- svn_fs_x__id_serialize(context, &node->fresh_root_predecessor_id);
- svn_temp_serializer__add_string(context, &node->created_path);
-
/* return serialized data */
serialized = svn_temp_serializer__get(context);
*data = serialized->data;
@@ -1153,14 +1176,13 @@ svn_fs_x__dag_deserialize(void **out,
node->fs = NULL;
/* fixup all references to sub-structures */
- svn_fs_x__id_deserialize(node, &node->id, pool);
- svn_fs_x__id_deserialize(node,
- (svn_fs_id_t **)&node->fresh_root_predecessor_id,
- pool);
svn_fs_x__noderev_deserialize(node, &node->node_revision, pool);
node->node_pool = pool;
- svn_temp_deserializer__resolve(node, (void**)&node->created_path);
+ if (node->node_revision)
+ node->created_path = node->node_revision->created_path;
+ else
+ svn_temp_deserializer__resolve(node, (void**)&node->created_path);
/* return result */
*out = node;
@@ -1175,12 +1197,11 @@ svn_fs_x__dag_open(dag_node_t **child_p,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
- const svn_fs_id_t *node_id;
+ svn_fs_x__id_t node_id;
/* Ensure that NAME exists in PARENT's entry list. */
- SVN_ERR(dir_entry_id_from_node(&node_id, parent, name,
- scratch_pool, scratch_pool));
- if (! node_id)
+ SVN_ERR(dir_entry_id_from_node(&node_id, parent, name, scratch_pool));
+ if (! svn_fs_x__id_used(&node_id))
{
*child_p = NULL;
return SVN_NO_ERROR;
@@ -1194,7 +1215,7 @@ svn_fs_x__dag_open(dag_node_t **child_p,
/* Now get the node that was requested. */
return svn_fs_x__dag_get_node(child_p, svn_fs_x__dag_get_fs(parent),
- node_id, result_pool);
+ &node_id, result_pool);
}
@@ -1208,13 +1229,12 @@ svn_fs_x__dag_copy(dag_node_t *to_node,
svn_fs_x__txn_id_t txn_id,
apr_pool_t *pool)
{
- const svn_fs_id_t *id;
+ const svn_fs_x__id_t *id;
if (preserve_history)
{
- node_revision_t *from_noderev, *to_noderev;
- svn_fs_x__id_part_t copy_id;
- const svn_fs_id_t *src_id = svn_fs_x__dag_get_id(from_node);
+ svn_fs_x__noderev_t *from_noderev, *to_noderev;
+ svn_fs_x__id_t copy_id;
svn_fs_t *fs = svn_fs_x__dag_get_fs(from_node);
/* Make a copy of the original node revision. */
@@ -1226,9 +1246,8 @@ svn_fs_x__dag_copy(dag_node_t *to_node,
/* Create a successor with its predecessor pointing at the copy
source. */
- to_noderev->predecessor_id = svn_fs_x__id_copy(src_id, pool);
- if (to_noderev->predecessor_count != -1)
- to_noderev->predecessor_count++;
+ to_noderev->predecessor_id = to_noderev->noderev_id;
+ to_noderev->predecessor_count++;
to_noderev->created_path =
svn_fspath__join(svn_fs_x__dag_get_created_path(to_node), entry,
pool);
@@ -1238,9 +1257,9 @@ svn_fs_x__dag_copy(dag_node_t *to_node,
/* Set the copyroot equal to our own id. */
to_noderev->copyroot_path = NULL;
- SVN_ERR(svn_fs_x__create_successor(&id, fs, src_id, to_noderev,
+ SVN_ERR(svn_fs_x__create_successor(fs, to_noderev,
©_id, txn_id, pool));
-
+ id = &to_noderev->noderev_id;
}
else /* don't preserve history */
{
@@ -1262,9 +1281,9 @@ svn_fs_x__dag_things_different(svn_boole
dag_node_t *node1,
dag_node_t *node2,
svn_boolean_t strict,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- node_revision_t *noderev1, *noderev2;
+ svn_fs_x__noderev_t *noderev1, *noderev2;
svn_fs_t *fs;
svn_boolean_t same;
@@ -1283,7 +1302,7 @@ svn_fs_x__dag_things_different(svn_boole
if (props_changed != NULL)
{
SVN_ERR(svn_fs_x__prop_rep_equal(&same, fs, noderev1, noderev2,
- strict, pool));
+ strict, scratch_pool));
*props_changed = !same;
}
@@ -1300,7 +1319,7 @@ svn_fs_x__dag_get_copyroot(svn_revnum_t
const char **path,
dag_node_t *node)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
/* Go get a fresh node-revision for NODE. */
SVN_ERR(get_node_revision(&noderev, node));
@@ -1315,7 +1334,7 @@ svn_error_t *
svn_fs_x__dag_get_copyfrom_rev(svn_revnum_t *rev,
dag_node_t *node)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
/* Go get a fresh node-revision for NODE. */
SVN_ERR(get_node_revision(&noderev, node));
@@ -1329,7 +1348,7 @@ svn_error_t *
svn_fs_x__dag_get_copyfrom_path(const char **path,
dag_node_t *node)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
/* Go get a fresh node-revision for NODE. */
SVN_ERR(get_node_revision(&noderev, node));
@@ -1342,9 +1361,9 @@ svn_fs_x__dag_get_copyfrom_path(const ch
svn_error_t *
svn_fs_x__dag_update_ancestry(dag_node_t *target,
dag_node_t *source,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- node_revision_t *source_noderev, *target_noderev;
+ svn_fs_x__noderev_t *source_noderev, *target_noderev;
if (! svn_fs_x__dag_check_mutable(target))
return svn_error_createf
@@ -1354,11 +1373,10 @@ svn_fs_x__dag_update_ancestry(dag_node_t
SVN_ERR(get_node_revision(&source_noderev, source));
SVN_ERR(get_node_revision(&target_noderev, target));
- target_noderev->predecessor_id = source->id;
+ target_noderev->predecessor_id = source_noderev->noderev_id;
target_noderev->predecessor_count = source_noderev->predecessor_count;
- if (target_noderev->predecessor_count != -1)
- target_noderev->predecessor_count++;
+ target_noderev->predecessor_count++;
- return svn_fs_x__put_node_revision(target->fs, target->id, target_noderev,
- FALSE, pool);
+ return svn_fs_x__put_node_revision(target->fs, target_noderev, FALSE,
+ scratch_pool);
}
Modified: subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.h
URL: http://svn.apache.org/viewvc/subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.h?rev=1652409&r1=1652408&r2=1652409&view=diff
==============================================================================
--- subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.h (original)
+++ subversion/branches/svn-auth-x509/subversion/libsvn_fs_x/dag.h Fri Jan 16 14:01:35 2015
@@ -27,6 +27,7 @@
#include "svn_delta.h"
#include "private/svn_cache.h"
+#include "fs.h"
#include "id.h"
#ifdef __cplusplus
@@ -64,21 +65,27 @@ extern "C" {
typedef struct dag_node_t dag_node_t;
/* Fill *NODE with a dag_node_t representing node revision ID in FS,
- allocating in POOL. */
+ allocating in RESULT_POOL. */
svn_error_t *
svn_fs_x__dag_get_node(dag_node_t **node,
svn_fs_t *fs,
- const svn_fs_id_t *id,
- apr_pool_t *pool);
+ const svn_fs_x__id_t *id,
+ apr_pool_t *result_pool);
/* Return a new dag_node_t object referring to the same node as NODE,
- allocated in POOL. If you're trying to build a structure in a
+ allocated in RESULT_POOL. If you're trying to build a structure in a
pool that wants to refer to dag nodes that may have been allocated
elsewhere, you can call this function and avoid inter-pool pointers. */
dag_node_t *
svn_fs_x__dag_dup(const dag_node_t *node,
- apr_pool_t *pool);
+ apr_pool_t *result_pool);
+
+/* If NODE has been allocated in POOL, return NODE. Otherwise, return
+ a copy created in RESULT_POOL with svn_fs_fs__dag_dup. */
+dag_node_t *
+svn_fs_x__dag_copy_into_pool(dag_node_t *node,
+ apr_pool_t *result_pool);
/* Serialize a DAG node, except don't try to preserve the 'fs' member.
Implements svn_cache__serialize_func_t */
@@ -97,50 +104,78 @@ svn_fs_x__dag_deserialize(void **out,
apr_pool_t *pool);
/* Return the filesystem containing NODE. */
-svn_fs_t *svn_fs_x__dag_get_fs(dag_node_t *node);
+svn_fs_t *
+svn_fs_x__dag_get_fs(dag_node_t *node);
/* Changes the filesystem containing NODE to FS. (Used when pulling
nodes out of a shared cache, say.) */
-void svn_fs_x__dag_set_fs(dag_node_t *node, svn_fs_t *fs);
+void
+svn_fs_x__dag_set_fs(dag_node_t *node,
+ svn_fs_t *fs);
-/* Set *REV to NODE's revision number, allocating in POOL. If NODE
- has never been committed as part of a revision, set *REV to
- SVN_INVALID_REVNUM. */
-svn_error_t *svn_fs_x__dag_get_revision(svn_revnum_t *rev,
- dag_node_t *node,
- apr_pool_t *pool);
+/* Return NODE's revision number. If NODE has never been committed as
+ part of a revision, set *REV to SVN_INVALID_REVNUM. */
+svn_revnum_t
+svn_fs_x__dag_get_revision(const dag_node_t *node);
/* Return the node revision ID of NODE. The value returned is shared
with NODE, and will be deallocated when NODE is. */
-const svn_fs_id_t *svn_fs_x__dag_get_id(const dag_node_t *node);
+const svn_fs_x__id_t *
+svn_fs_x__dag_get_id(const dag_node_t *node);
+
+/* Return the node ID of NODE. The value returned is shared with NODE,
+ and will be deallocated when NODE is. */
+svn_error_t *
+svn_fs_x__dag_get_node_id(svn_fs_x__id_t *node_id,
+ dag_node_t *node);
+
+/* Return the copy ID of NODE. The value returned is shared with NODE,
+ and will be deallocated when NODE is. */
+svn_error_t *
+svn_fs_x__dag_get_copy_id(svn_fs_x__id_t *copy_id,
+ dag_node_t *node);
+/* Set *SAME to TRUE, if nodes LHS and RHS have the same node ID. */
+svn_error_t *
+svn_fs_x__dag_related_node(svn_boolean_t *same,
+ dag_node_t *lhs,
+ dag_node_t *rhs);
+
+/* Set *SAME to TRUE, if nodes LHS and RHS have the same node and copy IDs.
+ */
+svn_error_t *
+svn_fs_x__dag_same_line_of_history(svn_boolean_t *same,
+ dag_node_t *lhs,
+ dag_node_t *rhs);
/* Return the created path of NODE. The value returned is shared
with NODE, and will be deallocated when NODE is. */
-const char *svn_fs_x__dag_get_created_path(dag_node_t *node);
+const char *
+svn_fs_x__dag_get_created_path(dag_node_t *node);
-/* Set *ID_P to the node revision ID of NODE's immediate predecessor,
- or NULL if NODE has no predecessor.
+/* Set *ID_P to the node revision ID of NODE's immediate predecessor.
*/
-svn_error_t *svn_fs_x__dag_get_predecessor_id(const svn_fs_id_t **id_p,
- dag_node_t *node);
+svn_error_t *
+svn_fs_x__dag_get_predecessor_id(svn_fs_x__id_t *id_p,
+ dag_node_t *node);
-/* Set *COUNT to the number of predecessors NODE has (recursively), or
- -1 if not known.
+/* Set *COUNT to the number of predecessors NODE has (recursively).
*/
/* ### This function is currently only used by 'verify'. */
-svn_error_t *svn_fs_x__dag_get_predecessor_count(int *count,
- dag_node_t *node);
+svn_error_t *
+svn_fs_x__dag_get_predecessor_count(int *count,
+ dag_node_t *node);
/* Set *COUNT to the number of node under NODE (inclusive) with
svn:mergeinfo properties.
*/
-svn_error_t *svn_fs_x__dag_get_mergeinfo_count(apr_int64_t *count,
- dag_node_t *node);
+svn_error_t *
+svn_fs_x__dag_get_mergeinfo_count(apr_int64_t *count,
+ dag_node_t *node);
/* Set *DO_THEY to a flag indicating whether or not NODE is a
directory with at least one descendant (not including itself) with
@@ -158,10 +193,12 @@ svn_fs_x__dag_has_mergeinfo(svn_boolean_
dag_node_t *node);
/* Return non-zero IFF NODE is currently mutable. */
-svn_boolean_t svn_fs_x__dag_check_mutable(const dag_node_t *node);
+svn_boolean_t
+svn_fs_x__dag_check_mutable(const dag_node_t *node);
/* Return the node kind of NODE. */
-svn_node_kind_t svn_fs_x__dag_node_kind(dag_node_t *node);
+svn_node_kind_t
+svn_fs_x__dag_node_kind(dag_node_t *node);
/* Set *PROPLIST_P to a PROPLIST hash representing the entire property
list of NODE, allocating from POOL. The hash has const char *
@@ -173,36 +210,40 @@ svn_node_kind_t svn_fs_x__dag_node_kind(
Use POOL for all allocations.
*/
-svn_error_t *svn_fs_x__dag_get_proplist(apr_hash_t **proplist_p,
- dag_node_t *node,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_get_proplist(apr_hash_t **proplist_p,
+ dag_node_t *node,
+ apr_pool_t *pool);
/* Set the property list of NODE to PROPLIST, allocating from POOL.
The node being changed must be mutable.
- Use POOL for all allocations.
+ Use SCRATCH_POOL for temporary allocations.
*/
-svn_error_t *svn_fs_x__dag_set_proplist(dag_node_t *node,
- apr_hash_t *proplist,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_set_proplist(dag_node_t *node,
+ apr_hash_t *proplist,
+ apr_pool_t *scratch_pool);
/* Increment the mergeinfo_count field on NODE by INCREMENT. The node
being changed must be mutable.
- Use POOL for all allocations.
+ Use SCRATCH_POOL for temporary allocations.
*/
-svn_error_t *svn_fs_x__dag_increment_mergeinfo_count(dag_node_t *node,
- apr_int64_t increment,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_increment_mergeinfo_count(dag_node_t *node,
+ apr_int64_t increment,
+ apr_pool_t *scratch_pool);
/* Set the has-mergeinfo flag on NODE to HAS_MERGEINFO. The node
being changed must be mutable.
- Use POOL for all allocations.
+ Use SCRATCH_POOL for temporary allocations.
*/
-svn_error_t *svn_fs_x__dag_set_has_mergeinfo(dag_node_t *node,
- svn_boolean_t has_mergeinfo,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_set_has_mergeinfo(dag_node_t *node,
+ svn_boolean_t has_mergeinfo,
+ apr_pool_t *scratch_pool);
@@ -211,10 +252,11 @@ svn_error_t *svn_fs_x__dag_set_has_merge
/* Open the root of revision REV of filesystem FS, allocating from
POOL. Set *NODE_P to the new node. */
-svn_error_t *svn_fs_x__dag_revision_root(dag_node_t **node_p,
- svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_revision_root(dag_node_t **node_p,
+ svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool);
/* Set *NODE_P to the root of transaction TXN_ID in FS, allocating
@@ -224,28 +266,31 @@ svn_error_t *svn_fs_x__dag_revision_root
no changes have been made in the transaction, then it may share its
root directory with its base revision. To get a mutable root node
for a transaction, call svn_fs_x__dag_clone_root. */
-svn_error_t *svn_fs_x__dag_txn_root(dag_node_t **node_p,
- svn_fs_t *fs,
- svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_txn_root(dag_node_t **node_p,
+ svn_fs_t *fs,
+ svn_fs_x__txn_id_t txn_id,
+ apr_pool_t *pool);
/* Set *NODE_P to the base root of transaction TXN_ID in FS,
allocating from POOL. Allocate the node in TRAIL->pool. */
-svn_error_t *svn_fs_x__dag_txn_base_root(dag_node_t **node_p,
- svn_fs_t *fs,
- svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_txn_base_root(dag_node_t **node_p,
+ svn_fs_t *fs,
+ svn_fs_x__txn_id_t txn_id,
+ apr_pool_t *pool);
/* Clone the root directory of TXN_ID in FS, and update the
`transactions' table entry to point to it, unless this has been
done already. In either case, set *ROOT_P to a reference to the
- root directory clone. Allocate *ROOT_P in POOL. */
-svn_error_t *svn_fs_x__dag_clone_root(dag_node_t **root_p,
- svn_fs_t *fs,
- svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool);
+ root directory clone. Allocate *ROOT_P in RESULT_POOL. */
+svn_error_t *
+svn_fs_x__dag_clone_root(dag_node_t **root_p,
+ svn_fs_t *fs,
+ svn_fs_x__txn_id_t txn_id,
+ apr_pool_t *result_pool);
@@ -266,24 +311,12 @@ svn_fs_x__dag_open(dag_node_t **child_p,
/* Set *ENTRIES_P to an array of NODE's entries, sorted by entry names,
- and the values are svn_fs_dirent_t's. The returned table (and elements)
+ and the values are svn_fs_x__dirent_t. The returned table (and elements)
is allocated in POOL, which is also used for temporary allocations. */
-svn_error_t *svn_fs_x__dag_dir_entries(apr_array_header_t **entries_p,
- dag_node_t *node,
- apr_pool_t *pool);
-
-/* Fetches the NODE's entries and returns a copy of the entry selected
- by the key value given in NAME and set *DIRENT to a copy of that
- entry. If such entry was found, the copy will be allocated in
- RESULT_POOL. Temporary data will be used in SCRATCH_POOL.
- Otherwise, the *DIRENT will be set to NULL.
- */
-/* ### This function is currently only called from dag.c. */
-svn_error_t * svn_fs_x__dag_dir_entry(svn_fs_dirent_t **dirent,
- dag_node_t *node,
- const char* name,
- apr_pool_t *result_pool,
- apr_pool_t *scratch_pool);
+svn_error_t *
+svn_fs_x__dag_dir_entries(apr_array_header_t **entries_p,
+ dag_node_t *node,
+ apr_pool_t *pool);
/* Set ENTRY_NAME in NODE to point to ID (with kind KIND), allocating
from POOL. NODE must be a mutable directory. ID can refer to a
@@ -291,15 +324,15 @@ svn_error_t * svn_fs_x__dag_dir_entry(sv
be created. TXN_ID is the Subversion transaction under which this
occurs.
- Use POOL for all allocations, including to cache the node_revision in
- NODE.
+ Use SCRATCH_POOL for temporary allocations.
*/
-svn_error_t *svn_fs_x__dag_set_entry(dag_node_t *node,
- const char *entry_name,
- const svn_fs_id_t *id,
- svn_node_kind_t kind,
- svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_set_entry(dag_node_t *node,
+ const char *entry_name,
+ const svn_fs_x__id_t *id,
+ svn_node_kind_t kind,
+ svn_fs_x__txn_id_t txn_id,
+ apr_pool_t *scratch_pool);
/* Make a new mutable clone of the node named NAME in PARENT, and
@@ -321,14 +354,15 @@ svn_error_t *svn_fs_x__dag_set_entry(dag
Use POOL for all allocations.
*/
-svn_error_t *svn_fs_x__dag_clone_child(dag_node_t **child_p,
- dag_node_t *parent,
- const char *parent_path,
- const char *name,
- const svn_fs_x__id_part_t *copy_id,
- svn_fs_x__txn_id_t txn_id,
- svn_boolean_t is_parent_copyroot,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_clone_child(dag_node_t **child_p,
+ dag_node_t *parent,
+ const char *parent_path,
+ const char *name,
+ const svn_fs_x__id_t *copy_id,
+ svn_fs_x__txn_id_t txn_id,
+ svn_boolean_t is_parent_copyroot,
+ apr_pool_t *pool);
/* Delete the directory entry named NAME from PARENT, allocating from
@@ -341,36 +375,26 @@ svn_error_t *svn_fs_x__dag_clone_child(d
If return SVN_ERR_FS_NO_SUCH_ENTRY, then there is no entry NAME in
PARENT.
- Use POOL for all allocations.
+ Use SCRATCH_POOL for temporary allocations.
*/
-svn_error_t *svn_fs_x__dag_delete(dag_node_t *parent,
- const char *name,
- svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool);
-
-
-/* Delete the node revision assigned to node ID from FS's `nodes'
- table, allocating from POOL. Also delete any mutable
- representations and strings associated with that node revision. ID
- may refer to a file or directory, which must be mutable.
-
- NOTE: If ID represents a directory, and that directory has mutable
- children, you risk orphaning those children by leaving them
- dangling, disconnected from all DAG trees. It is assumed that
- callers of this interface know what in the world they are doing. */
-svn_error_t *svn_fs_x__dag_remove_node(svn_fs_t *fs,
- const svn_fs_id_t *id,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_delete(dag_node_t *parent,
+ const char *name,
+ svn_fs_x__txn_id_t txn_id,
+ apr_pool_t *scratch_pool);
/* Delete all mutable node revisions reachable from node ID, including
- ID itself, from FS's `nodes' table, allocating from POOL. Also
- delete any mutable representations and strings associated with that
- node revision. ID may refer to a file or directory, which may be
- mutable or immutable. */
-svn_error_t *svn_fs_x__dag_delete_if_mutable(svn_fs_t *fs,
- const svn_fs_id_t *id,
- apr_pool_t *pool);
+ ID itself, from FS's `nodes' table. Also delete any mutable
+ representations and strings associated with that node revision.
+ ID may refer to a file or directory, which may be mutable or immutable.
+
+ Use SCRATCH_POOL for temporary allocations.
+ */
+svn_error_t *
+svn_fs_x__dag_delete_if_mutable(svn_fs_t *fs,
+ const svn_fs_x__id_t *id,
+ apr_pool_t *scratch_pool);
/* Create a new mutable directory named NAME in PARENT. Set *CHILD_P
@@ -384,12 +408,13 @@ svn_error_t *svn_fs_x__dag_delete_if_mut
Use POOL for all allocations.
*/
-svn_error_t *svn_fs_x__dag_make_dir(dag_node_t **child_p,
- dag_node_t *parent,
- const char *parent_path,
- const char *name,
- svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_make_dir(dag_node_t **child_p,
+ dag_node_t *parent,
+ const char *parent_path,
+ const char *name,
+ svn_fs_x__txn_id_t txn_id,
+ apr_pool_t *pool);
@@ -403,9 +428,10 @@ svn_error_t *svn_fs_x__dag_make_dir(dag_
Use POOL for all allocations.
*/
-svn_error_t *svn_fs_x__dag_get_contents(svn_stream_t **contents,
- dag_node_t *file,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_get_contents(svn_stream_t **contents,
+ dag_node_t *file,
+ apr_pool_t *pool);
/* Attempt to fetch the contents of NODE and pass it along with the BATON
to the PROCESSOR. Set *SUCCESS only of the data could be provided
@@ -441,9 +467,10 @@ svn_fs_x__dag_get_file_delta_stream(svn_
Use POOL for all allocations.
*/
-svn_error_t *svn_fs_x__dag_get_edit_stream(svn_stream_t **contents,
- dag_node_t *file,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_get_edit_stream(svn_stream_t **contents,
+ dag_node_t *file,
+ apr_pool_t *pool);
/* Signify the completion of edits to FILE made using the stream
@@ -455,35 +482,31 @@ svn_error_t *svn_fs_x__dag_get_edit_stre
This operation is a no-op if no edits are present.
- Use POOL for all allocations, including to cache the node_revision in
- FILE.
+ Use SCRATCH_POOL for temporary allocations.
*/
-svn_error_t *svn_fs_x__dag_finalize_edits(dag_node_t *file,
- const svn_checksum_t *checksum,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_finalize_edits(dag_node_t *file,
+ const svn_checksum_t *checksum,
+ apr_pool_t *scratch_pool);
/* Set *LENGTH to the length of the contents of FILE.
-
- Use POOL for all allocations.
*/
-svn_error_t *svn_fs_x__dag_file_length(svn_filesize_t *length,
- dag_node_t *file,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_file_length(svn_filesize_t *length,
+ dag_node_t *file);
/* Put the recorded checksum of type KIND for FILE into CHECKSUM, allocating
- from POOL.
+ from RESULT_POOL.
If no stored checksum is available, do not calculate the checksum,
just put NULL into CHECKSUM.
-
- Use POOL for all allocations.
*/
svn_error_t *
svn_fs_x__dag_file_checksum(svn_checksum_t **checksum,
dag_node_t *file,
svn_checksum_kind_t kind,
- apr_pool_t *pool);
+ apr_pool_t *result_pool);
/* Create a new mutable file named NAME in PARENT. Set *CHILD_P to a
reference to the new node, allocated in POOL. The new file's
@@ -495,12 +518,13 @@ svn_fs_x__dag_file_checksum(svn_checksum
Use POOL for all allocations.
*/
-svn_error_t *svn_fs_x__dag_make_file(dag_node_t **child_p,
- dag_node_t *parent,
- const char *parent_path,
- const char *name,
- svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_make_file(dag_node_t **child_p,
+ dag_node_t *parent,
+ const char *parent_path,
+ const char *name,
+ svn_fs_x__txn_id_t txn_id,
+ apr_pool_t *pool);
@@ -520,14 +544,15 @@ svn_error_t *svn_fs_x__dag_make_file(dag
Use POOL for all allocations.
*/
-svn_error_t *svn_fs_x__dag_copy(dag_node_t *to_node,
- const char *entry,
- dag_node_t *from_node,
- svn_boolean_t preserve_history,
- svn_revnum_t from_rev,
- const char *from_path,
- svn_fs_x__txn_id_t txn_id,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_copy(dag_node_t *to_node,
+ const char *entry,
+ dag_node_t *from_node,
+ svn_boolean_t preserve_history,
+ svn_revnum_t from_rev,
+ const char *from_path,
+ svn_fs_x__txn_id_t txn_id,
+ apr_pool_t *pool);
/* Comparison */
@@ -543,39 +568,45 @@ svn_error_t *svn_fs_x__dag_copy(dag_node
two nodes have different contents, or to 0 if same. NODE1 and NODE2
must refer to files from the same filesystem.
- Use POOL for temporary allocations.
+ Use SCRATCH_POOL for temporary allocations.
*/
-svn_error_t *svn_fs_x__dag_things_different(svn_boolean_t *props_changed,
- svn_boolean_t *contents_changed,
- dag_node_t *node1,
- dag_node_t *node2,
- svn_boolean_t strict,
- apr_pool_t *pool);
+svn_error_t *
+svn_fs_x__dag_things_different(svn_boolean_t *props_changed,
+ svn_boolean_t *contents_changed,
+ dag_node_t *node1,
+ dag_node_t *node2,
+ svn_boolean_t strict,
+ apr_pool_t *scratch_pool);
/* Set *REV and *PATH to the copyroot revision and path of node NODE, or
to SVN_INVALID_REVNUM and NULL if no copyroot exists.
*/
-svn_error_t *svn_fs_x__dag_get_copyroot(svn_revnum_t *rev,
- const char **path,
- dag_node_t *node);
+svn_error_t *
+svn_fs_x__dag_get_copyroot(svn_revnum_t *rev,
+ const char **path,
+ dag_node_t *node);
/* Set *REV to the copyfrom revision associated with NODE.
*/
-svn_error_t *svn_fs_x__dag_get_copyfrom_rev(svn_revnum_t *rev,
- dag_node_t *node);
+svn_error_t *
+svn_fs_x__dag_get_copyfrom_rev(svn_revnum_t *rev,
+ dag_node_t *node);
/* Set *PATH to the copyfrom path associated with NODE.
*/
-svn_error_t *svn_fs_x__dag_get_copyfrom_path(const char **path,
- dag_node_t *node);
+svn_error_t *
+svn_fs_x__dag_get_copyfrom_path(const char **path,
+ dag_node_t *node);
/* Update *TARGET so that SOURCE is it's predecessor.
+
+ Use SCRATCH_POOL for temporary allocations.
*/
svn_error_t *
svn_fs_x__dag_update_ancestry(dag_node_t *target,
dag_node_t *source,
- apr_pool_t *pool);
+ apr_pool_t *scratch_pool);
#ifdef __cplusplus
}
#endif /* __cplusplus */