subversion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From br...@apache.org
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 GMT
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,
                                          &copy_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 */



Mime
View raw message