You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by st...@apache.org on 2013/06/30 19:01:17 UTC
svn commit: r1498157 [2/11] - in
/subversion/branches/fsfs-format7/subversion: libsvn_fs_x/ tests/libsvn_fs_x/
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/changes.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/changes.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/changes.c (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/changes.c Sun Jun 30 17:01:16 2013
@@ -77,16 +77,16 @@ typedef struct binary_change_t
/* Relevant parts of the node revision ID of the change.
* Empty, if REV_ID is not "used". */
- svn_fs_fs__id_part_t node_id;
- svn_fs_fs__id_part_t copy_id;
- svn_fs_fs__id_part_t rev_id; /* txn ID if CHANGE_TXN_NODE set in FLAGS */
+ svn_fs_x__id_part_t node_id;
+ svn_fs_x__id_part_t copy_id;
+ svn_fs_x__id_part_t rev_id; /* txn ID if CHANGE_TXN_NODE set in FLAGS */
} binary_change_t;
/* The actual container object. Change lists are concatenated into CHANGES
* and and their begins and ends are stored in OFFSETS.
*/
-struct svn_fs_fs__changes_t
+struct svn_fs_x__changes_t
{
/* The paths - either in 'builder' mode or finalized mode.
* The respective other pointer will be NULL. */
@@ -106,11 +106,11 @@ struct svn_fs_fs__changes_t
* and initial capacity of INITIAL_COUNT changes. The PATH and BUILDER
* members must be initialized by the caller afterwards.
*/
-static svn_fs_fs__changes_t *
+static svn_fs_x__changes_t *
changes_create_body(apr_size_t initial_count,
apr_pool_t *pool)
{
- svn_fs_fs__changes_t *changes = apr_pcalloc(pool, sizeof(*changes));
+ svn_fs_x__changes_t *changes = apr_pcalloc(pool, sizeof(*changes));
changes->changes = apr_array_make(pool, (int)initial_count,
sizeof(binary_change_t));
@@ -120,12 +120,12 @@ changes_create_body(apr_size_t initial_c
return changes;
}
-svn_fs_fs__changes_t *
-svn_fs_fs__changes_create(apr_size_t initial_count,
- apr_pool_t *pool)
+svn_fs_x__changes_t *
+svn_fs_x__changes_create(apr_size_t initial_count,
+ apr_pool_t *pool)
{
- svn_fs_fs__changes_t *changes = changes_create_body(initial_count, pool);
- changes->builder = svn_fs_fs__string_table_builder_create(pool);
+ svn_fs_x__changes_t *changes = changes_create_body(initial_count, pool);
+ changes->builder = svn_fs_x__string_table_builder_create(pool);
return changes;
}
@@ -133,7 +133,7 @@ svn_fs_fs__changes_create(apr_size_t ini
/* Add CHANGE to the latest change list in CHANGES.
*/
static svn_error_t *
-append_change(svn_fs_fs__changes_t *changes,
+append_change(svn_fs_x__changes_t *changes,
change_t *change)
{
binary_change_t binary_change = { 0 };
@@ -146,7 +146,7 @@ append_change(svn_fs_fs__changes_t *chan
/* define the kind of change and what specific information is present */
info = &change->info;
- is_txn_id = info->node_rev_id && svn_fs_fs__id_is_txn(info->node_rev_id);
+ 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 ? CHANGE_TXN_NODE : 0)
@@ -155,18 +155,18 @@ append_change(svn_fs_fs__changes_t *chan
/* Path of the change. */
binary_change.path
- = svn_fs_fs__string_table_builder_add(changes->builder,
- change->path.data,
- change->path.len);
+ = svn_fs_x__string_table_builder_add(changes->builder,
+ change->path.data,
+ change->path.len);
/* copy-from information, if presence is indicated by FLAGS */
if (SVN_IS_VALID_REVNUM(info->copyfrom_rev))
{
binary_change.copyfrom_rev = info->copyfrom_rev;
binary_change.copyfrom_path
- = svn_fs_fs__string_table_builder_add(changes->builder,
- info->copyfrom_path,
- 0);
+ = svn_fs_x__string_table_builder_add(changes->builder,
+ info->copyfrom_path,
+ 0);
}
else
{
@@ -177,26 +177,26 @@ append_change(svn_fs_fs__changes_t *chan
/* Relevant parts of the revision ID of the change. */
if (info->node_rev_id)
{
- binary_change.node_id = *svn_fs_fs__id_node_id(info->node_rev_id);
- binary_change.copy_id = *svn_fs_fs__id_copy_id(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.rev_id = is_txn_id
- ? *svn_fs_fs__id_txn_id(info->node_rev_id)
- : *svn_fs_fs__id_rev_item(info->node_rev_id);
+ ? *svn_fs_x__id_txn_id(info->node_rev_id)
+ : *svn_fs_x__id_rev_item(info->node_rev_id);
}
else
{
- svn_fs_fs__id_txn_reset(&binary_change.rev_id);
+ svn_fs_x__id_txn_reset(&binary_change.rev_id);
}
-
+
APR_ARRAY_PUSH(changes->changes, binary_change_t) = binary_change;
return SVN_NO_ERROR;
}
svn_error_t *
-svn_fs_fs__changes_append_list(apr_size_t *list_index,
- svn_fs_fs__changes_t *changes,
- apr_array_header_t *list)
+svn_fs_x__changes_append_list(apr_size_t *list_index,
+ svn_fs_x__changes_t *changes,
+ apr_array_header_t *list)
{
int i;
@@ -216,7 +216,7 @@ svn_fs_fs__changes_append_list(apr_size_
}
apr_size_t
-svn_fs_fs__changes_estimate_size(const svn_fs_fs__changes_t *changes)
+svn_fs_x__changes_estimate_size(const svn_fs_x__changes_t *changes)
{
/* CHANGES must be in 'builder' mode */
if (changes->builder == NULL)
@@ -225,16 +225,16 @@ svn_fs_fs__changes_estimate_size(const s
/* string table code makes its own prediction,
* changes should be < 10 bytes each,
* some static overhead should be assumed */
- return svn_fs_fs__string_table_builder_estimate_size(changes->builder)
+ return svn_fs_x__string_table_builder_estimate_size(changes->builder)
+ changes->changes->nelts * 10
+ 100;
}
svn_error_t *
-svn_fs_fs__changes_get_list(apr_array_header_t **list,
- const svn_fs_fs__changes_t *changes,
- apr_size_t idx,
- apr_pool_t *pool)
+svn_fs_x__changes_get_list(apr_array_header_t **list,
+ const svn_fs_x__changes_t *changes,
+ apr_size_t idx,
+ apr_pool_t *pool)
{
int first;
int last;
@@ -265,22 +265,22 @@ svn_fs_fs__changes_get_list(apr_array_he
/* convert BINARY_CHANGE into a standard FSFS change_t */
change_t *change = apr_pcalloc(pool, sizeof(*change));
svn_fs_path_change2_t *info = &change->info;
- change->path.data = svn_fs_fs__string_table_get(changes->paths,
- binary_change->path,
- &change->path.len,
- pool);
+ change->path.data = svn_fs_x__string_table_get(changes->paths,
+ binary_change->path,
+ &change->path.len,
+ pool);
- if (svn_fs_fs__id_txn_used(&binary_change->rev_id))
+ if (svn_fs_x__id_txn_used(&binary_change->rev_id))
info->node_rev_id
= (binary_change->flags & CHANGE_TXN_NODE)
- ? svn_fs_fs__id_txn_create(&binary_change->node_id,
- &binary_change->copy_id,
- &binary_change->rev_id,
- pool)
- : svn_fs_fs__id_rev_create(&binary_change->node_id,
- &binary_change->copy_id,
- &binary_change->rev_id,
- pool);
+ ? svn_fs_x__id_txn_create(&binary_change->node_id,
+ &binary_change->copy_id,
+ &binary_change->rev_id,
+ pool)
+ : svn_fs_x__id_rev_create(&binary_change->node_id,
+ &binary_change->copy_id,
+ &binary_change->rev_id,
+ pool);
info->change_kind = (svn_fs_path_change_kind_t)
((binary_change->flags & CHANGE_KIND_MASK) >> CHANGE_KIND_SHIFT);
@@ -293,7 +293,7 @@ svn_fs_fs__changes_get_list(apr_array_he
info->copyfrom_known = TRUE;
if (SVN_IS_VALID_REVNUM(binary_change->copyfrom_rev))
info->copyfrom_path
- = svn_fs_fs__string_table_get(changes->paths,
+ = svn_fs_x__string_table_get(changes->paths,
binary_change->copyfrom_path,
NULL,
pool);
@@ -306,16 +306,16 @@ svn_fs_fs__changes_get_list(apr_array_he
}
svn_error_t *
-svn_fs_fs__write_changes_container(svn_stream_t *stream,
- const svn_fs_fs__changes_t *changes,
- apr_pool_t *pool)
+svn_fs_x__write_changes_container(svn_stream_t *stream,
+ const svn_fs_x__changes_t *changes,
+ apr_pool_t *pool)
{
int i;
string_table_t *paths = changes->paths
? changes->paths
- : svn_fs_fs__string_table_create(changes->builder,
- pool);
+ : svn_fs_x__string_table_create(changes->builder,
+ pool);
svn_packed__data_root_t *root = svn_packed__data_create_root(pool);
@@ -364,30 +364,30 @@ svn_fs_fs__write_changes_container(svn_s
}
/* write to disk */
- SVN_ERR(svn_fs_fs__write_string_table(stream, paths, pool));
+ SVN_ERR(svn_fs_x__write_string_table(stream, paths, pool));
SVN_ERR(svn_packed__data_write(stream, root, pool));
return SVN_NO_ERROR;
}
svn_error_t *
-svn_fs_fs__read_changes_container(svn_fs_fs__changes_t **changes_p,
- svn_stream_t *stream,
- apr_pool_t *result_pool,
- apr_pool_t *scratch_pool)
+svn_fs_x__read_changes_container(svn_fs_x__changes_t **changes_p,
+ svn_stream_t *stream,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
{
apr_size_t i;
apr_size_t count;
- svn_fs_fs__changes_t *changes = apr_pcalloc(result_pool, sizeof(*changes));
+ svn_fs_x__changes_t *changes = apr_pcalloc(result_pool, sizeof(*changes));
svn_packed__data_root_t *root;
svn_packed__int_stream_t *offsets_stream;
svn_packed__int_stream_t *changes_stream;
/* read from disk */
- SVN_ERR(svn_fs_fs__read_string_table(&changes->paths, stream,
- result_pool, scratch_pool));
+ SVN_ERR(svn_fs_x__read_string_table(&changes->paths, stream,
+ result_pool, scratch_pool));
SVN_ERR(svn_packed__data_read(&root, stream, result_pool, scratch_pool));
offsets_stream = svn_packed__first_int_stream(root);
@@ -431,12 +431,12 @@ svn_fs_fs__read_changes_container(svn_fs
}
svn_error_t *
-svn_fs_fs__serialize_changes_container(void **data,
- apr_size_t *data_len,
- void *in,
- apr_pool_t *pool)
+svn_fs_x__serialize_changes_container(void **data,
+ apr_size_t *data_len,
+ void *in,
+ apr_pool_t *pool)
{
- svn_fs_fs__changes_t *changes = in;
+ svn_fs_x__changes_t *changes = in;
svn_stringbuf_t *serialized;
/* make a guesstimate on the size of the serialized data. Erring on the
@@ -452,9 +452,9 @@ svn_fs_fs__serialize_changes_container(v
= svn_temp_serializer__init(changes, sizeof(*changes), size, pool);
/* serialize sub-structures */
- svn_fs_fs__serialize_string_table(context, &changes->paths);
- svn_fs_fs__serialize_apr_array(context, &changes->changes);
- svn_fs_fs__serialize_apr_array(context, &changes->offsets);
+ svn_fs_x__serialize_string_table(context, &changes->paths);
+ svn_fs_x__serialize_apr_array(context, &changes->changes);
+ svn_fs_x__serialize_apr_array(context, &changes->offsets);
/* return the serialized result */
serialized = svn_temp_serializer__get(context);
@@ -466,17 +466,17 @@ svn_fs_fs__serialize_changes_container(v
}
svn_error_t *
-svn_fs_fs__deserialize_changes_container(void **out,
+svn_fs_x__deserialize_changes_container(void **out,
void *data,
apr_size_t data_len,
apr_pool_t *pool)
{
- svn_fs_fs__changes_t *changes = (svn_fs_fs__changes_t *)data;
+ svn_fs_x__changes_t *changes = (svn_fs_x__changes_t *)data;
/* de-serialize sub-structures */
- svn_fs_fs__deserialize_string_table(changes, &changes->paths);
- svn_fs_fs__deserialize_apr_array(changes, &changes->changes, pool);
- svn_fs_fs__deserialize_apr_array(changes, &changes->offsets, pool);
+ svn_fs_x__deserialize_string_table(changes, &changes->paths);
+ svn_fs_x__deserialize_apr_array(changes, &changes->changes, pool);
+ svn_fs_x__deserialize_apr_array(changes, &changes->offsets, pool);
/* done */
*out = changes;
@@ -485,11 +485,11 @@ svn_fs_fs__deserialize_changes_container
}
svn_error_t *
-svn_fs_fs__changes_get_list_func(void **out,
- const void *data,
- apr_size_t data_len,
- void *baton,
- apr_pool_t *pool)
+svn_fs_x__changes_get_list_func(void **out,
+ const void *data,
+ apr_size_t data_len,
+ void *baton,
+ apr_pool_t *pool)
{
int first;
int last;
@@ -497,7 +497,7 @@ svn_fs_fs__changes_get_list_func(void **
apr_array_header_t *list;
apr_uint32_t idx = *(apr_uint32_t *)baton;
- const svn_fs_fs__changes_t *container = data;
+ const svn_fs_x__changes_t *container = data;
/* resolve all the sub-container pointers we need */
const string_table_t *paths
@@ -538,20 +538,20 @@ svn_fs_fs__changes_get_list_func(void **
change_t *change = apr_pcalloc(pool, sizeof(*change));
svn_fs_path_change2_t *info = &change->info;
change->path.data
- = svn_fs_fs__string_table_get_func(paths, binary_change->path,
- &change->path.len, pool);
+ = svn_fs_x__string_table_get_func(paths, binary_change->path,
+ &change->path.len, pool);
- if (svn_fs_fs__id_txn_used(&binary_change->rev_id))
+ if (svn_fs_x__id_txn_used(&binary_change->rev_id))
info->node_rev_id
= (binary_change->flags & CHANGE_TXN_NODE)
- ? svn_fs_fs__id_txn_create(&binary_change->node_id,
- &binary_change->copy_id,
- &binary_change->rev_id,
- pool)
- : svn_fs_fs__id_rev_create(&binary_change->node_id,
- &binary_change->copy_id,
- &binary_change->rev_id,
- pool);
+ ? svn_fs_x__id_txn_create(&binary_change->node_id,
+ &binary_change->copy_id,
+ &binary_change->rev_id,
+ pool)
+ : svn_fs_x__id_rev_create(&binary_change->node_id,
+ &binary_change->copy_id,
+ &binary_change->rev_id,
+ pool);
info->change_kind = (svn_fs_path_change_kind_t)
((binary_change->flags & CHANGE_KIND_MASK) >> CHANGE_KIND_SHIFT);
@@ -564,10 +564,10 @@ svn_fs_fs__changes_get_list_func(void **
info->copyfrom_known = TRUE;
if (SVN_IS_VALID_REVNUM(binary_change->copyfrom_rev))
info->copyfrom_path
- = svn_fs_fs__string_table_get_func(paths,
- binary_change->copyfrom_path,
- NULL,
- pool);
+ = 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;
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/changes.h
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/changes.h?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/changes.h (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/changes.h Sun Jun 30 17:01:16 2013
@@ -30,7 +30,7 @@
* changes to similar paths). Even more so, change lists from a larger
* revision range also tend to overlap.
*
- * In its serialized form, the svn_fs_fs__changes_t container extracts most
+ * 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.
*
@@ -41,31 +41,31 @@
/* An opaque collection of change lists (apr_array_header_t * of change_t*).
*/
-typedef struct svn_fs_fs__changes_t svn_fs_fs__changes_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.
*/
-svn_fs_fs__changes_t *
-svn_fs_fs__changes_create(apr_size_t initial_count,
- apr_pool_t *pool);
+svn_fs_x__changes_t *
+svn_fs_x__changes_create(apr_size_t initial_count,
+ apr_pool_t *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
* that new change list.
*/
svn_error_t *
-svn_fs_fs__changes_append_list(apr_size_t *list_index,
- svn_fs_fs__changes_t *changes,
- apr_array_header_t *list);
+svn_fs_x__changes_append_list(apr_size_t *list_index,
+ svn_fs_x__changes_t *changes,
+ apr_array_header_t *list);
/* Return a rough estimate in bytes for the serialized representation
* of CHANGES.
*/
apr_size_t
-svn_fs_fs__changes_estimate_size(const svn_fs_fs__changes_t *changes);
+svn_fs_x__changes_estimate_size(const svn_fs_x__changes_t *changes);
/* Read changes containers. */
@@ -73,10 +73,10 @@ svn_fs_fs__changes_estimate_size(const s
* the result in POOL and return it in *LIST.
*/
svn_error_t *
-svn_fs_fs__changes_get_list(apr_array_header_t **list,
- const svn_fs_fs__changes_t *changes,
- apr_size_t idx,
- apr_pool_t *pool);
+svn_fs_x__changes_get_list(apr_array_header_t **list,
+ const svn_fs_x__changes_t *changes,
+ apr_size_t idx,
+ apr_pool_t *pool);
/* I/O interface. */
@@ -84,47 +84,47 @@ svn_fs_fs__changes_get_list(apr_array_he
* temporary allocations.
*/
svn_error_t *
-svn_fs_fs__write_changes_container(svn_stream_t *stream,
- const svn_fs_fs__changes_t *changes,
- apr_pool_t *pool);
+svn_fs_x__write_changes_container(svn_stream_t *stream,
+ const svn_fs_x__changes_t *changes,
+ apr_pool_t *pool);
/* Read a changes container from its serialized representation in STREAM.
* Allocate the result in RESULT_POOL and return it in *CHANGES_P. Use
* SCRATCH_POOL for temporary allocations.
*/
svn_error_t *
-svn_fs_fs__read_changes_container(svn_fs_fs__changes_t **changes_p,
- svn_stream_t *stream,
- apr_pool_t *result_pool,
- apr_pool_t *scratch_pool);
+svn_fs_x__read_changes_container(svn_fs_x__changes_t **changes_p,
+ svn_stream_t *stream,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool);
-/* Implements #svn_cache__serialize_func_t for svn_fs_fs__changes_t objects.
+/* Implements #svn_cache__serialize_func_t for svn_fs_x__changes_t objects.
*/
svn_error_t *
-svn_fs_fs__serialize_changes_container(void **data,
- apr_size_t *data_len,
- void *in,
- apr_pool_t *pool);
+svn_fs_x__serialize_changes_container(void **data,
+ apr_size_t *data_len,
+ void *in,
+ apr_pool_t *pool);
-/* Implements #svn_cache__deserialize_func_t for svn_fs_fs__changes_t objects.
+/* Implements #svn_cache__deserialize_func_t for svn_fs_x__changes_t objects.
*/
svn_error_t *
-svn_fs_fs__deserialize_changes_container(void **out,
- void *data,
- apr_size_t data_len,
- apr_pool_t *pool);
+svn_fs_x__deserialize_changes_container(void **out,
+ void *data,
+ apr_size_t data_len,
+ apr_pool_t *pool);
-/* Implements svn_cache__partial_getter_func_t for svn_fs_fs__changes_t,
+/* Implements svn_cache__partial_getter_func_t for svn_fs_x__changes_t,
* setting *OUT to the change list (apr_array_header_t *) selected by
* the apr_uint32_t index passed in as *BATON. This function is similar
- * to svn_fs_fs__changes_get_list but operates on the cache serialized
+ * to svn_fs_x__changes_get_list but operates on the cache serialized
* representation of the container.
*/
svn_error_t *
-svn_fs_fs__changes_get_list_func(void **out,
- const void *data,
- apr_size_t data_len,
- void *baton,
- apr_pool_t *pool);
+svn_fs_x__changes_get_list_func(void **out,
+ const void *data,
+ apr_size_t data_len,
+ void *baton,
+ apr_pool_t *pool);
#endif
\ No newline at end of file
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/dag.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/dag.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/dag.c (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/dag.c Sun Jun 30 17:01:16 2013
@@ -81,34 +81,34 @@ struct dag_node_t
/* Trivial helper/accessor functions. */
-svn_node_kind_t svn_fs_fs__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 *
-svn_fs_fs__dag_get_id(const dag_node_t *node)
+svn_fs_x__dag_get_id(const dag_node_t *node)
{
return node->id;
}
const char *
-svn_fs_fs__dag_get_created_path(dag_node_t *node)
+svn_fs_x__dag_get_created_path(dag_node_t *node)
{
return node->created_path;
}
svn_fs_t *
-svn_fs_fs__dag_get_fs(dag_node_t *node)
+svn_fs_x__dag_get_fs(dag_node_t *node)
{
return node->fs;
}
void
-svn_fs_fs__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;
}
@@ -123,15 +123,15 @@ copy_node_revision(node_revision_t *node
node_revision_t *nr = apr_pcalloc(pool, sizeof(*nr));
nr->kind = noderev->kind;
if (noderev->predecessor_id)
- nr->predecessor_id = svn_fs_fs__id_copy(noderev->predecessor_id, pool);
+ nr->predecessor_id = svn_fs_x__id_copy(noderev->predecessor_id, pool);
nr->predecessor_count = noderev->predecessor_count;
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_fs__rep_copy(noderev->data_rep, pool);
- nr->prop_rep = svn_fs_fs__rep_copy(noderev->prop_rep, pool);
+ 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;
@@ -161,8 +161,8 @@ get_node_revision(node_revision_t **node
{
node_revision_t *noderev;
- SVN_ERR(svn_fs_fs__get_node_revision(&noderev, node->fs,
- node->id, node->node_pool));
+ SVN_ERR(svn_fs_x__get_node_revision(&noderev, node->fs,
+ node->id, node->node_pool));
node->node_revision = noderev;
}
@@ -172,17 +172,17 @@ get_node_revision(node_revision_t **node
}
-svn_boolean_t svn_fs_fs__dag_check_mutable(const dag_node_t *node)
+svn_boolean_t svn_fs_x__dag_check_mutable(const dag_node_t *node)
{
- return svn_fs_fs__id_is_txn(svn_fs_fs__dag_get_id(node));
+ return svn_fs_x__id_is_txn(svn_fs_x__dag_get_id(node));
}
svn_error_t *
-svn_fs_fs__dag_get_node(dag_node_t **node,
- svn_fs_t *fs,
- const svn_fs_id_t *id,
- apr_pool_t *pool)
+svn_fs_x__dag_get_node(dag_node_t **node,
+ svn_fs_t *fs,
+ const svn_fs_id_t *id,
+ apr_pool_t *pool)
{
dag_node_t *new_node;
node_revision_t *noderev;
@@ -190,7 +190,7 @@ svn_fs_fs__dag_get_node(dag_node_t **nod
/* Construct the node. */
new_node = apr_pcalloc(pool, sizeof(*new_node));
new_node->fs = fs;
- new_node->id = svn_fs_fs__id_copy(id, pool);
+ new_node->id = svn_fs_x__id_copy(id, pool);
/* Grab the contents so we can inspect the node's kind and created path. */
new_node->node_pool = pool;
@@ -212,9 +212,9 @@ svn_fs_fs__dag_get_node(dag_node_t **nod
svn_error_t *
-svn_fs_fs__dag_get_revision(svn_revnum_t *rev,
- dag_node_t *node,
- apr_pool_t *pool)
+svn_fs_x__dag_get_revision(svn_revnum_t *rev,
+ dag_node_t *node,
+ apr_pool_t *pool)
{
/* In the special case that this is an unmodified transaction root,
we need to actually get the revision of the noderev's predecessor
@@ -223,15 +223,15 @@ svn_fs_fs__dag_get_revision(svn_revnum_t
? node->fresh_root_predecessor_id : node->id;
/* Look up the committed revision from the Node-ID. */
- *rev = svn_fs_fs__id_rev(correct_id);
+ *rev = svn_fs_x__id_rev(correct_id);
return SVN_NO_ERROR;
}
svn_error_t *
-svn_fs_fs__dag_get_predecessor_id(const svn_fs_id_t **id_p,
- dag_node_t *node)
+svn_fs_x__dag_get_predecessor_id(const svn_fs_id_t **id_p,
+ dag_node_t *node)
{
node_revision_t *noderev;
@@ -242,8 +242,8 @@ svn_fs_fs__dag_get_predecessor_id(const
svn_error_t *
-svn_fs_fs__dag_get_predecessor_count(int *count,
- dag_node_t *node)
+svn_fs_x__dag_get_predecessor_count(int *count,
+ dag_node_t *node)
{
node_revision_t *noderev;
@@ -253,8 +253,8 @@ svn_fs_fs__dag_get_predecessor_count(int
}
svn_error_t *
-svn_fs_fs__dag_get_mergeinfo_count(apr_int64_t *count,
- dag_node_t *node)
+svn_fs_x__dag_get_mergeinfo_count(apr_int64_t *count,
+ dag_node_t *node)
{
node_revision_t *noderev;
@@ -264,8 +264,8 @@ svn_fs_fs__dag_get_mergeinfo_count(apr_i
}
svn_error_t *
-svn_fs_fs__dag_has_mergeinfo(svn_boolean_t *has_mergeinfo,
- dag_node_t *node)
+svn_fs_x__dag_has_mergeinfo(svn_boolean_t *has_mergeinfo,
+ dag_node_t *node)
{
node_revision_t *noderev;
@@ -275,8 +275,8 @@ svn_fs_fs__dag_has_mergeinfo(svn_boolean
}
svn_error_t *
-svn_fs_fs__dag_has_descendants_with_mergeinfo(svn_boolean_t *do_they,
- dag_node_t *node)
+svn_fs_x__dag_has_descendants_with_mergeinfo(svn_boolean_t *do_they,
+ dag_node_t *node)
{
node_revision_t *noderev;
@@ -313,8 +313,8 @@ dir_entry_id_from_node(const svn_fs_id_t
{
svn_fs_dirent_t *dirent;
- SVN_ERR(svn_fs_fs__dag_dir_entry(&dirent, parent, name, result_pool,
- scratch_pool));
+ SVN_ERR(svn_fs_x__dag_dir_entry(&dirent, parent, name, result_pool,
+ scratch_pool));
*id_p = dirent ? dirent->id : NULL;
return SVN_NO_ERROR;
@@ -334,7 +334,7 @@ set_entry(dag_node_t *parent,
const char *name,
const svn_fs_id_t *id,
svn_node_kind_t kind,
- const svn_fs_fs__id_part_t *txn_id,
+ const svn_fs_x__id_part_t *txn_id,
apr_pool_t *pool)
{
node_revision_t *parent_noderev;
@@ -343,8 +343,8 @@ set_entry(dag_node_t *parent,
SVN_ERR(get_node_revision(&parent_noderev, parent));
/* Set the new entry. */
- return svn_fs_fs__set_entry(parent->fs, txn_id, parent_noderev, name, id,
- kind, pool);
+ return svn_fs_x__set_entry(parent->fs, txn_id, parent_noderev, name, id,
+ kind, pool);
}
@@ -361,7 +361,7 @@ make_entry(dag_node_t **child_p,
const char *parent_path,
const char *name,
svn_boolean_t is_dir,
- const svn_fs_fs__id_part_t *txn_id,
+ const svn_fs_x__id_part_t *txn_id,
apr_pool_t *pool)
{
const svn_fs_id_t *new_node_id;
@@ -380,7 +380,7 @@ make_entry(dag_node_t **child_p,
_("Attempted to create entry in non-directory parent"));
/* Check that the parent is mutable. */
- if (! svn_fs_fs__dag_check_mutable(parent))
+ if (! svn_fs_x__dag_check_mutable(parent))
return svn_error_createf
(SVN_ERR_FS_NOT_MUTABLE, NULL,
_("Attempted to clone child of non-mutable node"));
@@ -397,25 +397,25 @@ make_entry(dag_node_t **child_p,
new_noderev.copyfrom_rev = SVN_INVALID_REVNUM;
new_noderev.copyfrom_path = NULL;
- SVN_ERR(svn_fs_fs__create_node
- (&new_node_id, svn_fs_fs__dag_get_fs(parent), &new_noderev,
- svn_fs_fs__id_copy_id(svn_fs_fs__dag_get_id(parent)),
+ 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));
/* Create a new dag_node_t for our new node */
- SVN_ERR(svn_fs_fs__dag_get_node(child_p, svn_fs_fs__dag_get_fs(parent),
- new_node_id, pool));
+ SVN_ERR(svn_fs_x__dag_get_node(child_p, svn_fs_x__dag_get_fs(parent),
+ new_node_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_fs__dag_get_id(*child_p),
+ return set_entry(parent, name, svn_fs_x__dag_get_id(*child_p),
new_noderev.kind, txn_id, pool);
}
svn_error_t *
-svn_fs_fs__dag_dir_entries(apr_hash_t **entries,
+svn_fs_x__dag_dir_entries(apr_hash_t **entries,
dag_node_t *node,
apr_pool_t *pool)
{
@@ -427,11 +427,11 @@ svn_fs_fs__dag_dir_entries(apr_hash_t **
return svn_error_create(SVN_ERR_FS_NOT_DIRECTORY, NULL,
_("Can't get entries of non-directory"));
- return svn_fs_fs__rep_contents_dir(entries, node->fs, noderev, pool);
+ return svn_fs_x__rep_contents_dir(entries, node->fs, noderev, pool);
}
svn_error_t *
-svn_fs_fs__dag_dir_entry(svn_fs_dirent_t **dirent,
+svn_fs_x__dag_dir_entry(svn_fs_dirent_t **dirent,
dag_node_t *node,
const char* name,
apr_pool_t *result_pool,
@@ -445,18 +445,18 @@ svn_fs_fs__dag_dir_entry(svn_fs_dirent_t
_("Can't get entries of non-directory"));
/* Get a dirent hash for this directory. */
- return svn_fs_fs__rep_contents_dir_entry(dirent, node->fs, noderev, name,
- result_pool, scratch_pool);
+ return svn_fs_x__rep_contents_dir_entry(dirent, node->fs, noderev, name,
+ result_pool, scratch_pool);
}
svn_error_t *
-svn_fs_fs__dag_set_entry(dag_node_t *node,
- const char *entry_name,
- const svn_fs_id_t *id,
- svn_node_kind_t kind,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+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,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
/* Check it's a directory. */
if (node->kind != svn_node_dir)
@@ -465,7 +465,7 @@ svn_fs_fs__dag_set_entry(dag_node_t *nod
_("Attempted to set entry in non-directory node"));
/* Check it's mutable. */
- if (! svn_fs_fs__dag_check_mutable(node))
+ if (! svn_fs_x__dag_check_mutable(node))
return svn_error_create
(SVN_ERR_FS_NOT_MUTABLE, NULL,
_("Attempted to set entry in immutable node"));
@@ -478,17 +478,16 @@ svn_fs_fs__dag_set_entry(dag_node_t *nod
/*** Proplists. ***/
svn_error_t *
-svn_fs_fs__dag_get_proplist(apr_hash_t **proplist_p,
- dag_node_t *node,
- apr_pool_t *pool)
+svn_fs_x__dag_get_proplist(apr_hash_t **proplist_p,
+ dag_node_t *node,
+ apr_pool_t *pool)
{
node_revision_t *noderev;
apr_hash_t *proplist = NULL;
SVN_ERR(get_node_revision(&noderev, node));
- SVN_ERR(svn_fs_fs__get_proplist(&proplist, node->fs,
- noderev, pool));
+ SVN_ERR(svn_fs_x__get_proplist(&proplist, node->fs, noderev, pool));
*proplist_p = proplist;
@@ -497,16 +496,16 @@ svn_fs_fs__dag_get_proplist(apr_hash_t *
svn_error_t *
-svn_fs_fs__dag_set_proplist(dag_node_t *node,
- apr_hash_t *proplist,
- apr_pool_t *pool)
+svn_fs_x__dag_set_proplist(dag_node_t *node,
+ apr_hash_t *proplist,
+ apr_pool_t *pool)
{
node_revision_t *noderev;
/* Sanity check: this node better be mutable! */
- if (! svn_fs_fs__dag_check_mutable(node))
+ if (! svn_fs_x__dag_check_mutable(node))
{
- svn_string_t *idstr = svn_fs_fs__id_unparse(node->id, pool);
+ svn_string_t *idstr = svn_fs_x__id_unparse(node->id, pool);
return svn_error_createf
(SVN_ERR_FS_NOT_MUTABLE, NULL,
"Can't set proplist on *immutable* node-revision %s",
@@ -517,21 +516,21 @@ svn_fs_fs__dag_set_proplist(dag_node_t *
SVN_ERR(get_node_revision(&noderev, node));
/* Set the new proplist. */
- return svn_fs_fs__set_proplist(node->fs, noderev, proplist, pool);
+ return svn_fs_x__set_proplist(node->fs, noderev, proplist, pool);
}
svn_error_t *
-svn_fs_fs__dag_increment_mergeinfo_count(dag_node_t *node,
- apr_int64_t increment,
- apr_pool_t *pool)
+svn_fs_x__dag_increment_mergeinfo_count(dag_node_t *node,
+ apr_int64_t increment,
+ apr_pool_t *pool)
{
node_revision_t *noderev;
/* Sanity check: this node better be mutable! */
- if (! svn_fs_fs__dag_check_mutable(node))
+ if (! svn_fs_x__dag_check_mutable(node))
{
- svn_string_t *idstr = svn_fs_fs__id_unparse(node->id, pool);
+ svn_string_t *idstr = svn_fs_x__id_unparse(node->id, pool);
return svn_error_createf
(SVN_ERR_FS_NOT_MUTABLE, NULL,
"Can't increment mergeinfo count on *immutable* node-revision %s",
@@ -547,7 +546,7 @@ svn_fs_fs__dag_increment_mergeinfo_count
noderev->mergeinfo_count += increment;
if (noderev->mergeinfo_count < 0)
{
- svn_string_t *idstr = svn_fs_fs__id_unparse(node->id, pool);
+ svn_string_t *idstr = svn_fs_x__id_unparse(node->id, pool);
return svn_error_createf
(SVN_ERR_FS_CORRUPT, NULL,
apr_psprintf(pool,
@@ -558,7 +557,7 @@ svn_fs_fs__dag_increment_mergeinfo_count
}
if (noderev->mergeinfo_count > 1 && noderev->kind == svn_node_file)
{
- svn_string_t *idstr = svn_fs_fs__id_unparse(node->id, pool);
+ svn_string_t *idstr = svn_fs_x__id_unparse(node->id, pool);
return svn_error_createf
(SVN_ERR_FS_CORRUPT, NULL,
apr_psprintf(pool,
@@ -569,21 +568,21 @@ svn_fs_fs__dag_increment_mergeinfo_count
}
/* Flush it out. */
- return svn_fs_fs__put_node_revision(node->fs, noderev->id,
- noderev, FALSE, pool);
+ return svn_fs_x__put_node_revision(node->fs, noderev->id,
+ noderev, FALSE, pool);
}
svn_error_t *
-svn_fs_fs__dag_set_has_mergeinfo(dag_node_t *node,
+svn_fs_x__dag_set_has_mergeinfo(dag_node_t *node,
svn_boolean_t has_mergeinfo,
apr_pool_t *pool)
{
node_revision_t *noderev;
/* Sanity check: this node better be mutable! */
- if (! svn_fs_fs__dag_check_mutable(node))
+ if (! svn_fs_x__dag_check_mutable(node))
{
- svn_string_t *idstr = svn_fs_fs__id_unparse(node->id, pool);
+ svn_string_t *idstr = svn_fs_x__id_unparse(node->id, pool);
return svn_error_createf
(SVN_ERR_FS_NOT_MUTABLE, NULL,
"Can't set mergeinfo flag on *immutable* node-revision %s",
@@ -596,25 +595,25 @@ svn_fs_fs__dag_set_has_mergeinfo(dag_nod
noderev->has_mergeinfo = has_mergeinfo;
/* Flush it out. */
- return svn_fs_fs__put_node_revision(node->fs, noderev->id,
- noderev, FALSE, pool);
+ return svn_fs_x__put_node_revision(node->fs, noderev->id,
+ noderev, FALSE, pool);
}
/*** Roots. ***/
svn_error_t *
-svn_fs_fs__dag_revision_root(dag_node_t **node_p,
- svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool)
+svn_fs_x__dag_revision_root(dag_node_t **node_p,
+ svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool)
{
dag_node_t *new_node;
/* Construct the node. */
new_node = apr_pcalloc(pool, sizeof(*new_node));
new_node->fs = fs;
- SVN_ERR(svn_fs_fs__rev_get_root(&new_node->id, fs, rev, pool));
+ SVN_ERR(svn_fs_x__rev_get_root(&new_node->id, fs, rev, pool));
/* Grab the contents so we can inspect the node's kind and created path. */
new_node->node_pool = pool;
@@ -631,48 +630,48 @@ svn_fs_fs__dag_revision_root(dag_node_t
svn_error_t *
-svn_fs_fs__dag_txn_root(dag_node_t **node_p,
- svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__dag_txn_root(dag_node_t **node_p,
+ svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
const svn_fs_id_t *root_id, *ignored;
- SVN_ERR(svn_fs_fs__get_txn_ids(&root_id, &ignored, fs, txn_id, pool));
- return svn_fs_fs__dag_get_node(node_p, fs, root_id, pool);
+ 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_error_t *
-svn_fs_fs__dag_txn_base_root(dag_node_t **node_p,
- svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
+svn_fs_x__dag_txn_base_root(dag_node_t **node_p,
+ svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
apr_pool_t *pool)
{
const svn_fs_id_t *base_root_id, *ignored;
- SVN_ERR(svn_fs_fs__get_txn_ids(&ignored, &base_root_id, fs, txn_id, pool));
- return svn_fs_fs__dag_get_node(node_p, fs, base_root_id, pool);
+ 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_error_t *
-svn_fs_fs__dag_clone_child(dag_node_t **child_p,
- dag_node_t *parent,
- const char *parent_path,
- const char *name,
- const svn_fs_fs__id_part_t *copy_id,
- const svn_fs_fs__id_part_t *txn_id,
- svn_boolean_t is_parent_copyroot,
- apr_pool_t *pool)
+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,
+ const svn_fs_x__id_part_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 */
- svn_fs_t *fs = svn_fs_fs__dag_get_fs(parent);
+ svn_fs_t *fs = svn_fs_x__dag_get_fs(parent);
apr_pool_t *subpool = svn_pool_create(pool);
/* First check that the parent is mutable. */
- if (! svn_fs_fs__dag_check_mutable(parent))
+ if (! svn_fs_x__dag_check_mutable(parent))
return svn_error_createf
(SVN_ERR_FS_NOT_MUTABLE, NULL,
"Attempted to clone child of non-mutable node");
@@ -684,11 +683,11 @@ svn_fs_fs__dag_clone_child(dag_node_t **
"Attempted to make a child clone with an illegal name '%s'", name);
/* Find the node named NAME in PARENT's entries list if it exists. */
- SVN_ERR(svn_fs_fs__dag_open(&cur_entry, parent, name, pool, subpool));
+ SVN_ERR(svn_fs_x__dag_open(&cur_entry, parent, name, pool, subpool));
/* Check for mutability in the node we found. If it's mutable, we
don't need to clone it. */
- if (svn_fs_fs__dag_check_mutable(cur_entry))
+ if (svn_fs_x__dag_check_mutable(cur_entry))
{
/* This has already been cloned */
new_node_id = cur_entry->id;
@@ -711,12 +710,12 @@ svn_fs_fs__dag_clone_child(dag_node_t **
noderev->copyfrom_path = NULL;
noderev->copyfrom_rev = SVN_INVALID_REVNUM;
- noderev->predecessor_id = svn_fs_fs__id_copy(cur_entry->id, pool);
+ noderev->predecessor_id = svn_fs_x__id_copy(cur_entry->id, pool);
if (noderev->predecessor_count != -1)
noderev->predecessor_count++;
noderev->created_path = svn_fspath__join(parent_path, name, pool);
- SVN_ERR(svn_fs_fs__create_successor(&new_node_id, fs, cur_entry->id,
+ SVN_ERR(svn_fs_x__create_successor(&new_node_id, fs, cur_entry->id,
noderev, copy_id, txn_id, pool));
/* Replace the ID in the parent's ENTRY list with the ID which
@@ -727,27 +726,27 @@ svn_fs_fs__dag_clone_child(dag_node_t **
/* Initialize the youngster. */
svn_pool_destroy(subpool);
- return svn_fs_fs__dag_get_node(child_p, fs, new_node_id, pool);
+ return svn_fs_x__dag_get_node(child_p, fs, new_node_id, pool);
}
svn_error_t *
-svn_fs_fs__dag_clone_root(dag_node_t **root_p,
- svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__dag_clone_root(dag_node_t **root_p,
+ svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *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_fs__get_txn_ids(&root_id, &base_root_id, fs, txn_id, pool));
+ 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_fs__id_eq(root_id, base_root_id));
+ 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
@@ -755,15 +754,15 @@ svn_fs_fs__dag_clone_root(dag_node_t **r
*/
/* One way or another, root_id now identifies a cloned root node. */
- return svn_fs_fs__dag_get_node(root_p, fs, root_id, pool);
+ return svn_fs_x__dag_get_node(root_p, fs, root_id, pool);
}
svn_error_t *
-svn_fs_fs__dag_delete(dag_node_t *parent,
- const char *name,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__dag_delete(dag_node_t *parent,
+ const char *name,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
node_revision_t *parent_noderev;
svn_fs_t *fs = parent->fs;
@@ -778,7 +777,7 @@ svn_fs_fs__dag_delete(dag_node_t *parent
"Attempted to delete entry '%s' from *non*-directory node", name);
/* Make sure parent is mutable. */
- if (! svn_fs_fs__dag_check_mutable(parent))
+ if (! svn_fs_x__dag_check_mutable(parent))
return svn_error_createf
(SVN_ERR_FS_NOT_MUTABLE, NULL,
"Attempted to delete entry '%s' from immutable directory node", name);
@@ -795,8 +794,8 @@ svn_fs_fs__dag_delete(dag_node_t *parent
subpool = svn_pool_create(pool);
/* Search this directory for a dirent with that NAME. */
- SVN_ERR(svn_fs_fs__rep_contents_dir_entry(&dirent, fs, parent_noderev,
- name, subpool, subpool));
+ SVN_ERR(svn_fs_x__rep_contents_dir_entry(&dirent, fs, parent_noderev,
+ name, subpool, subpool));
/* If we never found ID in ENTRIES (perhaps because there are no
ENTRIES, perhaps because ID just isn't in the existing ENTRIES
@@ -808,50 +807,50 @@ svn_fs_fs__dag_delete(dag_node_t *parent
/* Copy the ID out of the subpool and release the rest of the
directory listing. */
- id = svn_fs_fs__id_copy(dirent->id, pool);
+ 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_fs__dag_delete_if_mutable(parent->fs, id, pool));
+ SVN_ERR(svn_fs_x__dag_delete_if_mutable(parent->fs, id, pool));
/* Remove this entry from its parent's entries list. */
- return svn_fs_fs__set_entry(parent->fs, txn_id, parent_noderev, name,
- NULL, svn_node_unknown, pool);
+ return svn_fs_x__set_entry(parent->fs, txn_id, parent_noderev, name,
+ NULL, svn_node_unknown, pool);
}
svn_error_t *
-svn_fs_fs__dag_remove_node(svn_fs_t *fs,
- const svn_fs_id_t *id,
- apr_pool_t *pool)
+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_fs__dag_get_node(&node, fs, id, pool));
+ SVN_ERR(svn_fs_x__dag_get_node(&node, fs, id, pool));
/* If immutable, do nothing and return immediately. */
- if (! svn_fs_fs__dag_check_mutable(node))
+ 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_fs__delete_node_revision(fs, id, pool);
+ return svn_fs_x__delete_node_revision(fs, id, pool);
}
svn_error_t *
-svn_fs_fs__dag_delete_if_mutable(svn_fs_t *fs,
- const svn_fs_id_t *id,
- apr_pool_t *pool)
+svn_fs_x__dag_delete_if_mutable(svn_fs_t *fs,
+ const svn_fs_id_t *id,
+ apr_pool_t *pool)
{
dag_node_t *node;
/* Get the node. */
- SVN_ERR(svn_fs_fs__dag_get_node(&node, fs, id, pool));
+ SVN_ERR(svn_fs_x__dag_get_node(&node, fs, id, pool));
/* If immutable, do nothing and return immediately. */
- if (! svn_fs_fs__dag_check_mutable(node))
+ if (! svn_fs_x__dag_check_mutable(node))
return SVN_NO_ERROR;
/* Else it's mutable. Recurse on directories... */
@@ -861,7 +860,7 @@ svn_fs_fs__dag_delete_if_mutable(svn_fs_
apr_hash_index_t *hi;
/* Loop over hash entries */
- SVN_ERR(svn_fs_fs__dag_dir_entries(&entries, node, pool));
+ SVN_ERR(svn_fs_x__dag_dir_entries(&entries, node, pool));
if (entries)
{
for (hi = apr_hash_first(pool, entries);
@@ -870,24 +869,23 @@ svn_fs_fs__dag_delete_if_mutable(svn_fs_
{
svn_fs_dirent_t *dirent = svn__apr_hash_index_val(hi);
- SVN_ERR(svn_fs_fs__dag_delete_if_mutable(fs, dirent->id,
- pool));
+ SVN_ERR(svn_fs_x__dag_delete_if_mutable(fs, dirent->id, pool));
}
}
}
/* ... then delete the node itself, after deleting any mutable
representations and strings it points to. */
- return svn_fs_fs__dag_remove_node(fs, id, pool);
+ return svn_fs_x__dag_remove_node(fs, id, pool);
}
svn_error_t *
-svn_fs_fs__dag_make_file(dag_node_t **child_p,
- dag_node_t *parent,
- const char *parent_path,
- const char *name,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__dag_make_file(dag_node_t **child_p,
+ dag_node_t *parent,
+ const char *parent_path,
+ const char *name,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
/* Call our little helper function */
return make_entry(child_p, parent, parent_path, name, FALSE, txn_id, pool);
@@ -895,12 +893,12 @@ svn_fs_fs__dag_make_file(dag_node_t **ch
svn_error_t *
-svn_fs_fs__dag_make_dir(dag_node_t **child_p,
- dag_node_t *parent,
- const char *parent_path,
- const char *name,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__dag_make_dir(dag_node_t **child_p,
+ dag_node_t *parent,
+ const char *parent_path,
+ const char *name,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
/* Call our little helper function */
return make_entry(child_p, parent, parent_path, name, TRUE, txn_id, pool);
@@ -908,9 +906,9 @@ svn_fs_fs__dag_make_dir(dag_node_t **chi
svn_error_t *
-svn_fs_fs__dag_get_contents(svn_stream_t **contents_p,
- dag_node_t *file,
- apr_pool_t *pool)
+svn_fs_x__dag_get_contents(svn_stream_t **contents_p,
+ dag_node_t *file,
+ apr_pool_t *pool)
{
node_revision_t *noderev;
svn_stream_t *contents;
@@ -925,8 +923,8 @@ svn_fs_fs__dag_get_contents(svn_stream_t
SVN_ERR(get_node_revision(&noderev, file));
/* Get a stream to the contents. */
- SVN_ERR(svn_fs_fs__get_contents(&contents, file->fs,
- noderev->data_rep, pool));
+ SVN_ERR(svn_fs_x__get_contents(&contents, file->fs,
+ noderev->data_rep, pool));
*contents_p = contents;
@@ -935,10 +933,10 @@ svn_fs_fs__dag_get_contents(svn_stream_t
svn_error_t *
-svn_fs_fs__dag_get_file_delta_stream(svn_txdelta_stream_t **stream_p,
- dag_node_t *source,
- dag_node_t *target,
- apr_pool_t *pool)
+svn_fs_x__dag_get_file_delta_stream(svn_txdelta_stream_t **stream_p,
+ dag_node_t *source,
+ dag_node_t *target,
+ apr_pool_t *pool)
{
node_revision_t *src_noderev;
node_revision_t *tgt_noderev;
@@ -958,33 +956,33 @@ svn_fs_fs__dag_get_file_delta_stream(svn
SVN_ERR(get_node_revision(&tgt_noderev, target));
/* Get the delta stream. */
- return svn_fs_fs__get_file_delta_stream(stream_p, target->fs,
- src_noderev, tgt_noderev, pool);
+ return svn_fs_x__get_file_delta_stream(stream_p, target->fs,
+ src_noderev, tgt_noderev, pool);
}
svn_error_t *
-svn_fs_fs__dag_try_process_file_contents(svn_boolean_t *success,
- dag_node_t *node,
- svn_fs_process_contents_func_t processor,
- void* baton,
- apr_pool_t *pool)
+svn_fs_x__dag_try_process_file_contents(svn_boolean_t *success,
+ dag_node_t *node,
+ svn_fs_process_contents_func_t processor,
+ void* baton,
+ apr_pool_t *pool)
{
node_revision_t *noderev;
/* Go get fresh node-revisions for the nodes. */
SVN_ERR(get_node_revision(&noderev, node));
- return svn_fs_fs__try_process_file_contents(success, node->fs,
- noderev,
- processor, baton, pool);
+ return svn_fs_x__try_process_file_contents(success, node->fs,
+ noderev,
+ processor, baton, pool);
}
svn_error_t *
-svn_fs_fs__dag_file_length(svn_filesize_t *length,
- dag_node_t *file,
- apr_pool_t *pool)
+svn_fs_x__dag_file_length(svn_filesize_t *length,
+ dag_node_t *file,
+ apr_pool_t *pool)
{
node_revision_t *noderev;
@@ -997,15 +995,15 @@ svn_fs_fs__dag_file_length(svn_filesize_
/* Go get a fresh node-revision for FILE, and . */
SVN_ERR(get_node_revision(&noderev, file));
- return svn_fs_fs__file_length(length, noderev, pool);
+ return svn_fs_x__file_length(length, noderev, pool);
}
svn_error_t *
-svn_fs_fs__dag_file_checksum(svn_checksum_t **checksum,
- dag_node_t *file,
- svn_checksum_kind_t kind,
- apr_pool_t *pool)
+svn_fs_x__dag_file_checksum(svn_checksum_t **checksum,
+ dag_node_t *file,
+ svn_checksum_kind_t kind,
+ apr_pool_t *pool)
{
node_revision_t *noderev;
@@ -1016,14 +1014,14 @@ svn_fs_fs__dag_file_checksum(svn_checksu
SVN_ERR(get_node_revision(&noderev, file));
- return svn_fs_fs__file_checksum(checksum, noderev, kind, pool);
+ return svn_fs_x__file_checksum(checksum, noderev, kind, pool);
}
svn_error_t *
-svn_fs_fs__dag_get_edit_stream(svn_stream_t **contents,
- dag_node_t *file,
- apr_pool_t *pool)
+svn_fs_x__dag_get_edit_stream(svn_stream_t **contents,
+ dag_node_t *file,
+ apr_pool_t *pool)
{
node_revision_t *noderev;
svn_stream_t *ws;
@@ -1035,7 +1033,7 @@ svn_fs_fs__dag_get_edit_stream(svn_strea
"Attempted to set textual contents of a *non*-file node");
/* Make sure our node is mutable. */
- if (! svn_fs_fs__dag_check_mutable(file))
+ if (! svn_fs_x__dag_check_mutable(file))
return svn_error_createf
(SVN_ERR_FS_NOT_MUTABLE, NULL,
"Attempted to set textual contents of an immutable node");
@@ -1043,7 +1041,7 @@ svn_fs_fs__dag_get_edit_stream(svn_strea
/* Get the node revision. */
SVN_ERR(get_node_revision(&noderev, file));
- SVN_ERR(svn_fs_fs__set_contents(&ws, file->fs, noderev, pool));
+ SVN_ERR(svn_fs_x__set_contents(&ws, file->fs, noderev, pool));
*contents = ws;
@@ -1053,16 +1051,16 @@ svn_fs_fs__dag_get_edit_stream(svn_strea
svn_error_t *
-svn_fs_fs__dag_finalize_edits(dag_node_t *file,
- const svn_checksum_t *checksum,
- apr_pool_t *pool)
+svn_fs_x__dag_finalize_edits(dag_node_t *file,
+ const svn_checksum_t *checksum,
+ apr_pool_t *pool)
{
if (checksum)
{
svn_checksum_t *file_checksum;
- SVN_ERR(svn_fs_fs__dag_file_checksum(&file_checksum, file,
- checksum->kind, pool));
+ SVN_ERR(svn_fs_x__dag_file_checksum(&file_checksum, file,
+ checksum->kind, pool));
if (!svn_checksum_match(checksum, file_checksum))
return svn_checksum_mismatch_err(checksum, file_checksum, pool,
_("Checksum mismatch for '%s'"),
@@ -1074,23 +1072,23 @@ svn_fs_fs__dag_finalize_edits(dag_node_t
dag_node_t *
-svn_fs_fs__dag_dup(const dag_node_t *node,
- apr_pool_t *pool)
+svn_fs_x__dag_dup(const dag_node_t *node,
+ apr_pool_t *pool)
{
/* Allocate our new node. */
dag_node_t *new_node = apr_pcalloc(pool, sizeof(*new_node));
new_node->fs = node->fs;
- new_node->id = svn_fs_fs__id_copy(node->id, pool);
+ 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. */
- if (node->node_revision && !svn_fs_fs__dag_check_mutable(node))
+ 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_fs__id_copy(node->node_revision->id, pool);
+ 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;
}
@@ -1100,10 +1098,10 @@ svn_fs_fs__dag_dup(const dag_node_t *nod
}
svn_error_t *
-svn_fs_fs__dag_serialize(void **data,
- apr_size_t *data_len,
- void *in,
- apr_pool_t *pool)
+svn_fs_x__dag_serialize(void **data,
+ apr_size_t *data_len,
+ void *in,
+ apr_pool_t *pool)
{
dag_node_t *node = in;
svn_stringbuf_t *serialized;
@@ -1116,8 +1114,8 @@ svn_fs_fs__dag_serialize(void **data,
pool);
/* for mutable nodes, we will _never_ cache the noderev */
- if (node->node_revision && !svn_fs_fs__dag_check_mutable(node))
- svn_fs_fs__noderev_serialize(context, &node->node_revision);
+ if (node->node_revision && !svn_fs_x__dag_check_mutable(node))
+ svn_fs_x__noderev_serialize(context, &node->node_revision);
else
svn_temp_serializer__set_null(context,
(const void * const *)&node->node_revision);
@@ -1127,8 +1125,8 @@ svn_fs_fs__dag_serialize(void **data,
(const void * const *)&node->node_pool);
/* serialize other sub-structures */
- svn_fs_fs__id_serialize(context, (const svn_fs_id_t **)&node->id);
- svn_fs_fs__id_serialize(context, &node->fresh_root_predecessor_id);
+ 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 */
@@ -1140,10 +1138,10 @@ svn_fs_fs__dag_serialize(void **data,
}
svn_error_t *
-svn_fs_fs__dag_deserialize(void **out,
- void *data,
- apr_size_t data_len,
- apr_pool_t *pool)
+svn_fs_x__dag_deserialize(void **out,
+ void *data,
+ apr_size_t data_len,
+ apr_pool_t *pool)
{
dag_node_t *node = (dag_node_t *)data;
if (data_len == 0)
@@ -1154,10 +1152,10 @@ svn_fs_fs__dag_deserialize(void **out,
node->fs = NULL;
/* fixup all references to sub-structures */
- svn_fs_fs__id_deserialize(node, &node->id);
- svn_fs_fs__id_deserialize(node,
+ svn_fs_x__id_deserialize(node, &node->id);
+ svn_fs_x__id_deserialize(node,
(svn_fs_id_t **)&node->fresh_root_predecessor_id);
- svn_fs_fs__noderev_deserialize(node, &node->node_revision);
+ svn_fs_x__noderev_deserialize(node, &node->node_revision);
node->node_pool = pool;
svn_temp_deserializer__resolve(node, (void**)&node->created_path);
@@ -1169,11 +1167,11 @@ svn_fs_fs__dag_deserialize(void **out,
}
svn_error_t *
-svn_fs_fs__dag_open(dag_node_t **child_p,
- dag_node_t *parent,
- const char *name,
- apr_pool_t *result_pool,
- apr_pool_t *scratch_pool)
+svn_fs_x__dag_open(dag_node_t **child_p,
+ dag_node_t *parent,
+ const char *name,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
{
const svn_fs_id_t *node_id;
@@ -1192,63 +1190,63 @@ svn_fs_fs__dag_open(dag_node_t **child_p
"Attempted to open node with an illegal name '%s'", name);
/* Now get the node that was requested. */
- return svn_fs_fs__dag_get_node(child_p, svn_fs_fs__dag_get_fs(parent),
- node_id, result_pool);
+ return svn_fs_x__dag_get_node(child_p, svn_fs_x__dag_get_fs(parent),
+ node_id, result_pool);
}
svn_error_t *
-svn_fs_fs__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,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+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,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
const svn_fs_id_t *id;
if (preserve_history)
{
node_revision_t *from_noderev, *to_noderev;
- svn_fs_fs__id_part_t copy_id;
- const svn_fs_id_t *src_id = svn_fs_fs__dag_get_id(from_node);
- svn_fs_t *fs = svn_fs_fs__dag_get_fs(from_node);
+ 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_t *fs = svn_fs_x__dag_get_fs(from_node);
/* Make a copy of the original node revision. */
SVN_ERR(get_node_revision(&from_noderev, from_node));
to_noderev = copy_node_revision(from_noderev, pool);
/* Reserve a copy ID for this new copy. */
- SVN_ERR(svn_fs_fs__reserve_copy_id(©_id, fs, txn_id, pool));
+ SVN_ERR(svn_fs_x__reserve_copy_id(©_id, fs, txn_id, pool));
/* Create a successor with its predecessor pointing at the copy
source. */
- to_noderev->predecessor_id = svn_fs_fs__id_copy(src_id, pool);
+ to_noderev->predecessor_id = svn_fs_x__id_copy(src_id, pool);
if (to_noderev->predecessor_count != -1)
to_noderev->predecessor_count++;
to_noderev->created_path =
- svn_fspath__join(svn_fs_fs__dag_get_created_path(to_node), entry,
- pool);
+ svn_fspath__join(svn_fs_x__dag_get_created_path(to_node), entry,
+ pool);
to_noderev->copyfrom_path = apr_pstrdup(pool, from_path);
to_noderev->copyfrom_rev = from_rev;
/* Set the copyroot equal to our own id. */
to_noderev->copyroot_path = NULL;
- SVN_ERR(svn_fs_fs__create_successor(&id, fs, src_id, to_noderev,
- ©_id, txn_id, pool));
+ SVN_ERR(svn_fs_x__create_successor(&id, fs, src_id, to_noderev,
+ ©_id, txn_id, pool));
}
else /* don't preserve history */
{
- id = svn_fs_fs__dag_get_id(from_node);
+ id = svn_fs_x__dag_get_id(from_node);
}
/* Set the entry in to_node to the new id. */
- return svn_fs_fs__dag_set_entry(to_node, entry, id, from_node->kind,
- txn_id, pool);
+ return svn_fs_x__dag_set_entry(to_node, entry, id, from_node->kind,
+ txn_id, pool);
}
@@ -1256,10 +1254,10 @@ svn_fs_fs__dag_copy(dag_node_t *to_node,
/*** Comparison. ***/
svn_error_t *
-svn_fs_fs__dag_things_different(svn_boolean_t *props_changed,
- svn_boolean_t *contents_changed,
- dag_node_t *node1,
- dag_node_t *node2)
+svn_fs_x__dag_things_different(svn_boolean_t *props_changed,
+ svn_boolean_t *contents_changed,
+ dag_node_t *node1,
+ dag_node_t *node2)
{
node_revision_t *noderev1, *noderev2;
@@ -1274,22 +1272,22 @@ svn_fs_fs__dag_things_different(svn_bool
/* Compare property keys. */
if (props_changed != NULL)
- *props_changed = (! svn_fs_fs__noderev_same_rep_key(noderev1->prop_rep,
- noderev2->prop_rep));
+ *props_changed = (! svn_fs_x__noderev_same_rep_key(noderev1->prop_rep,
+ noderev2->prop_rep));
/* Compare contents keys. */
if (contents_changed != NULL)
*contents_changed =
- (! svn_fs_fs__noderev_same_rep_key(noderev1->data_rep,
- noderev2->data_rep));
+ (! svn_fs_x__noderev_same_rep_key(noderev1->data_rep,
+ noderev2->data_rep));
return SVN_NO_ERROR;
}
svn_error_t *
-svn_fs_fs__dag_get_copyroot(svn_revnum_t *rev,
- const char **path,
- dag_node_t *node)
+svn_fs_x__dag_get_copyroot(svn_revnum_t *rev,
+ const char **path,
+ dag_node_t *node)
{
node_revision_t *noderev;
@@ -1303,8 +1301,8 @@ svn_fs_fs__dag_get_copyroot(svn_revnum_t
}
svn_error_t *
-svn_fs_fs__dag_get_copyfrom_rev(svn_revnum_t *rev,
- dag_node_t *node)
+svn_fs_x__dag_get_copyfrom_rev(svn_revnum_t *rev,
+ dag_node_t *node)
{
node_revision_t *noderev;
@@ -1317,8 +1315,8 @@ svn_fs_fs__dag_get_copyfrom_rev(svn_revn
}
svn_error_t *
-svn_fs_fs__dag_get_copyfrom_path(const char **path,
- dag_node_t *node)
+svn_fs_x__dag_get_copyfrom_path(const char **path,
+ dag_node_t *node)
{
node_revision_t *noderev;
@@ -1331,13 +1329,13 @@ svn_fs_fs__dag_get_copyfrom_path(const c
}
svn_error_t *
-svn_fs_fs__dag_update_ancestry(dag_node_t *target,
- dag_node_t *source,
- apr_pool_t *pool)
+svn_fs_x__dag_update_ancestry(dag_node_t *target,
+ dag_node_t *source,
+ apr_pool_t *pool)
{
node_revision_t *source_noderev, *target_noderev;
- if (! svn_fs_fs__dag_check_mutable(target))
+ if (! svn_fs_x__dag_check_mutable(target))
return svn_error_createf
(SVN_ERR_FS_NOT_MUTABLE, NULL,
_("Attempted to update ancestry of non-mutable node"));
@@ -1350,6 +1348,6 @@ svn_fs_fs__dag_update_ancestry(dag_node_
if (target_noderev->predecessor_count != -1)
target_noderev->predecessor_count++;
- return svn_fs_fs__put_node_revision(target->fs, target->id, target_noderev,
- FALSE, pool);
+ return svn_fs_x__put_node_revision(target->fs, target->id, target_noderev,
+ FALSE, pool);
}