Return-Path: X-Original-To: apmail-subversion-commits-archive@minotaur.apache.org Delivered-To: apmail-subversion-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 289E410967 for ; Fri, 16 Jan 2015 14:01:46 +0000 (UTC) Received: (qmail 27347 invoked by uid 500); 16 Jan 2015 14:01:42 -0000 Delivered-To: apmail-subversion-commits-archive@subversion.apache.org Received: (qmail 27172 invoked by uid 500); 16 Jan 2015 14:01:42 -0000 Mailing-List: contact commits-help@subversion.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@subversion.apache.org Delivered-To: mailing list commits@subversion.apache.org Received: (qmail 27016 invoked by uid 99); 16 Jan 2015 14:01:42 -0000 Received: from eris.apache.org (HELO hades.apache.org) (140.211.11.105) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 16 Jan 2015 14:01:42 +0000 Received: from hades.apache.org (localhost [127.0.0.1]) by hades.apache.org (ASF Mail Server at hades.apache.org) with ESMTP id D2CECAC08DB; Fri, 16 Jan 2015 14:01:41 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: 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... Date: Fri, 16 Jan 2015 14:01:37 -0000 To: commits@subversion.apache.org From: brane@apache.org X-Mailer: svnmailer-1.0.9 Message-Id: <20150116140141.D2CECAC08DB@hades.apache.org> 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 */