You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by hw...@apache.org on 2011/08/05 17:20:24 UTC
svn commit: r1154262 [3/4] - in /subversion/branches/fs-py: ./
subversion/libsvn_fs_py/
Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/fs_fs.h
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/fs_fs.h?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/fs_fs.h (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/fs_fs.h Fri Aug 5 15:20:23 2011
@@ -30,37 +30,37 @@
### Some parts of *FS must have been initialized beforehand; some parts
(including FS->path) are initialized by this function. */
-svn_error_t *svn_fs_fs__open(svn_fs_t *fs,
+svn_error_t *svn_fs_py__open(svn_fs_t *fs,
const char *path,
apr_pool_t *pool);
/* Upgrade the fsfs filesystem FS. Use POOL for temporary allocations. */
-svn_error_t *svn_fs_fs__upgrade(svn_fs_t *fs,
+svn_error_t *svn_fs_py__upgrade(svn_fs_t *fs,
apr_pool_t *pool);
/* Verify the fsfs filesystem FS. Use POOL for temporary allocations. */
-svn_error_t *svn_fs_fs__verify(svn_fs_t *fs,
+svn_error_t *svn_fs_py__verify(svn_fs_t *fs,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool);
/* Copy the fsfs filesystem at SRC_PATH into a new copy at DST_PATH.
Use POOL for temporary allocations. */
-svn_error_t *svn_fs_fs__hotcopy(const char *src_path,
+svn_error_t *svn_fs_py__hotcopy(const char *src_path,
const char *dst_path,
apr_pool_t *pool);
/* Recover the fsfs associated with filesystem FS.
Use optional CANCEL_FUNC/CANCEL_BATON for cancellation support.
Use POOL for temporary allocations. */
-svn_error_t *svn_fs_fs__recover(svn_fs_t *fs,
+svn_error_t *svn_fs_py__recover(svn_fs_t *fs,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool);
/* Set *NODEREV_P to the node-revision for the node ID in FS. Do any
allocations in POOL. */
-svn_error_t *svn_fs_fs__get_node_revision(node_revision_t **noderev_p,
+svn_error_t *svn_fs_py__get_node_revision(node_revision_t **noderev_p,
svn_fs_t *fs,
const svn_fs_id_t *id,
apr_pool_t *pool);
@@ -68,7 +68,7 @@ svn_error_t *svn_fs_fs__get_node_revisio
/* Store NODEREV as the node-revision for the node whose id is ID in
FS, after setting its is_fresh_txn_root to FRESH_TXN_ROOT. Do any
necessary temporary allocation in POOL. */
-svn_error_t *svn_fs_fs__put_node_revision(svn_fs_t *fs,
+svn_error_t *svn_fs_py__put_node_revision(svn_fs_t *fs,
const svn_fs_id_t *id,
node_revision_t *noderev,
svn_boolean_t fresh_txn_root,
@@ -78,7 +78,7 @@ svn_error_t *svn_fs_fs__put_node_revisio
filesystem format FORMAT. Only write mergeinfo-related metadata if
INCLUDE_MERGEINFO is true. Temporary allocations are from POOL. */
svn_error_t *
-svn_fs_fs__write_noderev(svn_stream_t *outfile,
+svn_fs_py__write_noderev(svn_stream_t *outfile,
node_revision_t *noderev,
int format,
svn_boolean_t include_mergeinfo,
@@ -88,20 +88,20 @@ svn_fs_fs__write_noderev(svn_stream_t *o
allocated in POOL. */
/* ### Currently used only by fs_fs.c */
svn_error_t *
-svn_fs_fs__read_noderev(node_revision_t **noderev,
+svn_fs_py__read_noderev(node_revision_t **noderev,
svn_stream_t *stream,
apr_pool_t *pool);
/* Set *YOUNGEST to the youngest revision in filesystem FS. Do any
temporary allocation in POOL. */
-svn_error_t *svn_fs_fs__youngest_rev(svn_revnum_t *youngest,
+svn_error_t *svn_fs_py__youngest_rev(svn_revnum_t *youngest,
svn_fs_t *fs,
apr_pool_t *pool);
/* Set *ROOT_ID to the node-id for the root of revision REV in
filesystem FS. Do any allocations in POOL. */
-svn_error_t *svn_fs_fs__rev_get_root(svn_fs_id_t **root_id,
+svn_error_t *svn_fs_py__rev_get_root(svn_fs_id_t **root_id,
svn_fs_t *fs,
svn_revnum_t rev,
apr_pool_t *pool);
@@ -110,7 +110,7 @@ svn_error_t *svn_fs_fs__rev_get_root(svn
directory entries of node-revision NODEREV in filesystem FS. The
returned table (and its keys and values) is allocated in POOL,
which is also used for temporary allocations. */
-svn_error_t *svn_fs_fs__rep_contents_dir(apr_hash_t **entries,
+svn_error_t *svn_fs_py__rep_contents_dir(apr_hash_t **entries,
svn_fs_t *fs,
node_revision_t *noderev,
apr_pool_t *pool);
@@ -119,7 +119,7 @@ svn_error_t *svn_fs_fs__rep_contents_dir
by NODEREV in filesystem FS. The returned object is allocated in POOL,
which is also used for temporary allocations. */
svn_error_t *
-svn_fs_fs__rep_contents_dir_entry(svn_fs_dirent_t **dirent,
+svn_fs_py__rep_contents_dir_entry(svn_fs_dirent_t **dirent,
svn_fs_t *fs,
node_revision_t *noderev,
const char *name,
@@ -128,7 +128,7 @@ svn_fs_fs__rep_contents_dir_entry(svn_fs
/* Set *CONTENTS to be a readable svn_stream_t that receives the text
representation of node-revision NODEREV as seen in filesystem FS.
Use POOL for temporary allocations. */
-svn_error_t *svn_fs_fs__get_contents(svn_stream_t **contents,
+svn_error_t *svn_fs_py__get_contents(svn_stream_t **contents,
svn_fs_t *fs,
node_revision_t *noderev,
apr_pool_t *pool);
@@ -136,7 +136,7 @@ svn_error_t *svn_fs_fs__get_contents(svn
/* Set *STREAM_P to a delta stream turning the contents of the file SOURCE into
the contents of the file TARGET, allocated in POOL.
If SOURCE is null, the empty string will be used. */
-svn_error_t *svn_fs_fs__get_file_delta_stream(svn_txdelta_stream_t **stream_p,
+svn_error_t *svn_fs_py__get_file_delta_stream(svn_txdelta_stream_t **stream_p,
svn_fs_t *fs,
node_revision_t *source,
node_revision_t *target,
@@ -145,7 +145,7 @@ svn_error_t *svn_fs_fs__get_file_delta_s
/* Set *PROPLIST to be an apr_hash_t containing the property list of
node-revision NODEREV as seen in filesystem FS. Use POOL for
temporary allocations. */
-svn_error_t *svn_fs_fs__get_proplist(apr_hash_t **proplist,
+svn_error_t *svn_fs_py__get_proplist(apr_hash_t **proplist,
svn_fs_t *fs,
node_revision_t *noderev,
apr_pool_t *pool);
@@ -153,32 +153,32 @@ svn_error_t *svn_fs_fs__get_proplist(apr
/* Set *PROPLIST to be an apr_hash_t containing the property list of
revision REV as seen in filesystem FS. Use POOL for temporary
allocations. */
-svn_error_t *svn_fs_fs__revision_proplist(apr_hash_t **proplist,
+svn_error_t *svn_fs_py__revision_proplist(apr_hash_t **proplist,
svn_fs_t *fs,
svn_revnum_t rev,
apr_pool_t *pool);
/* Set *LENGTH to the be fulltext length of the node revision
specified by NODEREV. Use POOL for temporary allocations. */
-svn_error_t *svn_fs_fs__file_length(svn_filesize_t *length,
+svn_error_t *svn_fs_py__file_length(svn_filesize_t *length,
node_revision_t *noderev,
apr_pool_t *pool);
/* Return TRUE if the representation keys in A and B both point to the
same representation, else return FALSE. */
-svn_boolean_t svn_fs_fs__noderev_same_rep_key(representation_t *a,
+svn_boolean_t svn_fs_py__noderev_same_rep_key(representation_t *a,
representation_t *b);
/* Return a copy of the representation REP allocated from POOL. */
-representation_t *svn_fs_fs__rep_copy(representation_t *rep,
+representation_t *svn_fs_py__rep_copy(representation_t *rep,
apr_pool_t *pool);
/* Return the recorded checksum of type KIND for the text representation
of NODREV into CHECKSUM, allocating from POOL. If no stored checksum is
available, put all NULL into CHECKSUM. */
-svn_error_t *svn_fs_fs__file_checksum(svn_checksum_t **checksum,
+svn_error_t *svn_fs_py__file_checksum(svn_checksum_t **checksum,
node_revision_t *noderev,
svn_checksum_kind_t kind,
apr_pool_t *pool);
@@ -187,7 +187,7 @@ svn_error_t *svn_fs_fs__file_checksum(sv
and store them in *CHANGED_PATHS_P. Cached copyfrom information
will be stored in *COPYFROM_CACHE. Get any temporary allocations
from POOL. */
-svn_error_t *svn_fs_fs__paths_changed(apr_hash_t **changed_paths_p,
+svn_error_t *svn_fs_py__paths_changed(apr_hash_t **changed_paths_p,
svn_fs_t *fs,
svn_revnum_t rev,
apr_hash_t *copyfrom_cache,
@@ -196,44 +196,44 @@ svn_error_t *svn_fs_fs__paths_changed(ap
/* Create a new transaction in filesystem FS, based on revision REV,
and store it in *TXN_P. Allocate all necessary variables from
POOL. */
-svn_error_t *svn_fs_fs__create_txn(svn_fs_txn_t **txn_p,
+svn_error_t *svn_fs_py__create_txn(svn_fs_txn_t **txn_p,
svn_fs_t *fs,
svn_revnum_t rev,
apr_pool_t *pool);
/* Set the transaction property NAME to the value VALUE in transaction
TXN. Perform temporary allocations from POOL. */
-svn_error_t *svn_fs_fs__change_txn_prop(svn_fs_txn_t *txn,
+svn_error_t *svn_fs_py__change_txn_prop(svn_fs_txn_t *txn,
const char *name,
const svn_string_t *value,
apr_pool_t *pool);
/* Change transaction properties in transaction TXN based on PROPS.
Perform temporary allocations from POOL. */
-svn_error_t *svn_fs_fs__change_txn_props(svn_fs_txn_t *txn,
+svn_error_t *svn_fs_py__change_txn_props(svn_fs_txn_t *txn,
const apr_array_header_t *props,
apr_pool_t *pool);
/* Return whether or not the given FS supports mergeinfo metadata. */
-svn_boolean_t svn_fs_fs__fs_supports_mergeinfo(svn_fs_t *fs);
+svn_boolean_t svn_fs_py__fs_supports_mergeinfo(svn_fs_t *fs);
/* Store a transaction record in *TXN_P for the transaction identified
by TXN_ID in filesystem FS. Allocate everything from POOL. */
-svn_error_t *svn_fs_fs__get_txn(transaction_t **txn_p,
+svn_error_t *svn_fs_py__get_txn(transaction_t **txn_p,
svn_fs_t *fs,
const char *txn_id,
apr_pool_t *pool);
/* Abort the existing transaction TXN, performing any temporary
allocations in POOL. */
-svn_error_t *svn_fs_fs__abort_txn(svn_fs_txn_t *txn, apr_pool_t *pool);
+svn_error_t *svn_fs_py__abort_txn(svn_fs_txn_t *txn, apr_pool_t *pool);
/* Create an entirely new mutable node in the filesystem FS, whose
node-revision is NODEREV. Set *ID_P to the new node revision's ID.
Use POOL for any temporary allocation. COPY_ID is the copy_id to
use in the node revision ID. TXN_ID is the Subversion transaction
under which this occurs. */
-svn_error_t *svn_fs_fs__create_node(const svn_fs_id_t **id_p,
+svn_error_t *svn_fs_py__create_node(const svn_fs_id_t **id_p,
svn_fs_t *fs,
node_revision_t *noderev,
const char *copy_id,
@@ -242,14 +242,14 @@ svn_error_t *svn_fs_fs__create_node(cons
/* Remove all references to the transaction TXN_ID from filesystem FS.
Temporary allocations are from POOL. */
-svn_error_t *svn_fs_fs__purge_txn(svn_fs_t *fs,
+svn_error_t *svn_fs_py__purge_txn(svn_fs_t *fs,
const char *txn_id,
apr_pool_t *pool);
/* Add or set in filesystem FS, transaction TXN_ID, in directory
PARENT_NODEREV a directory entry for NAME pointing to ID of type
KIND. Allocations are done in POOL. */
-svn_error_t *svn_fs_fs__set_entry(svn_fs_t *fs,
+svn_error_t *svn_fs_py__set_entry(svn_fs_t *fs,
const char *txn_id,
node_revision_t *parent_noderev,
const char *name,
@@ -265,7 +265,7 @@ svn_error_t *svn_fs_fs__set_entry(svn_fs
revision and path of the copy source, otherwise they should be set
to SVN_INVALID_REVNUM and NULL. Perform any temporary allocations
from POOL. */
-svn_error_t *svn_fs_fs__add_change(svn_fs_t *fs,
+svn_error_t *svn_fs_py__add_change(svn_fs_t *fs,
const char *txn_id,
const char *path,
const svn_fs_id_t *id,
@@ -280,7 +280,7 @@ svn_error_t *svn_fs_fs__add_change(svn_f
/* Return a writable stream in *STREAM that allows storing the text
representation of node-revision NODEREV in filesystem FS.
Allocations are from POOL. */
-svn_error_t *svn_fs_fs__set_contents(svn_stream_t **stream,
+svn_error_t *svn_fs_py__set_contents(svn_stream_t **stream,
svn_fs_t *fs,
node_revision_t *noderev,
apr_pool_t *pool);
@@ -299,7 +299,7 @@ svn_error_t *svn_fs_fs__set_contents(svn
After this call, the deltification code assumes that the new node's
contents will change frequently, and will avoid representing other
nodes as deltas against this node's contents. */
-svn_error_t *svn_fs_fs__create_successor(const svn_fs_id_t **new_id_p,
+svn_error_t *svn_fs_py__create_successor(const svn_fs_id_t **new_id_p,
svn_fs_t *fs,
const svn_fs_id_t *old_idp,
node_revision_t *new_noderev,
@@ -309,7 +309,7 @@ svn_error_t *svn_fs_fs__create_successor
/* Write a new property list PROPLIST for node-revision NODEREV in
filesystem FS. Perform any temporary allocations in POOL. */
-svn_error_t *svn_fs_fs__set_proplist(svn_fs_t *fs,
+svn_error_t *svn_fs_py__set_proplist(svn_fs_t *fs,
node_revision_t *noderev,
apr_hash_t *proplist,
apr_pool_t *pool);
@@ -318,14 +318,14 @@ svn_error_t *svn_fs_fs__set_proplist(svn
revision number in *REV. If the transaction is out of date, return
the error SVN_ERR_FS_TXN_OUT_OF_DATE. Use POOL for temporary
allocations. */
-svn_error_t *svn_fs_fs__commit(svn_revnum_t *new_rev_p,
+svn_error_t *svn_fs_py__commit(svn_revnum_t *new_rev_p,
svn_fs_t *fs,
svn_fs_txn_t *txn,
apr_pool_t *pool);
/* Return the next available copy_id in *COPY_ID for the transaction
TXN_ID in filesystem FS. Allocate space in POOL. */
-svn_error_t *svn_fs_fs__reserve_copy_id(const char **copy_id,
+svn_error_t *svn_fs_py__reserve_copy_id(const char **copy_id,
svn_fs_t *fs,
const char *txn_id,
apr_pool_t *pool);
@@ -335,26 +335,26 @@ svn_error_t *svn_fs_fs__reserve_copy_id(
### Some parts of *FS must have been initialized beforehand; some parts
(including FS->path) are initialized by this function. */
-svn_error_t *svn_fs_fs__create(svn_fs_t *fs,
+svn_error_t *svn_fs_py__create(svn_fs_t *fs,
const char *path,
apr_pool_t *pool);
/* Store the uuid of the repository FS in *UUID. Allocate space in
POOL. */
-svn_error_t *svn_fs_fs__get_uuid(svn_fs_t *fs,
+svn_error_t *svn_fs_py__get_uuid(svn_fs_t *fs,
const char **uuid,
apr_pool_t *pool);
/* Set the uuid of repository FS to UUID, if UUID is not NULL;
otherwise, set the uuid of FS to a newly generated UUID. Perform
temporary allocations in POOL. */
-svn_error_t *svn_fs_fs__set_uuid(svn_fs_t *fs,
+svn_error_t *svn_fs_py__set_uuid(svn_fs_t *fs,
const char *uuid,
apr_pool_t *pool);
/* Set *NAMES_P to an array of names which are all the active
transactions in filesystem FS. Allocate the array from POOL. */
-svn_error_t *svn_fs_fs__list_transactions(apr_array_header_t **names_p,
+svn_error_t *svn_fs_py__list_transactions(apr_array_header_t **names_p,
svn_fs_t *fs,
apr_pool_t *pool);
@@ -362,21 +362,21 @@ svn_error_t *svn_fs_fs__list_transaction
* the transaction. If there is no such transaction, return
` * SVN_ERR_FS_NO_SUCH_TRANSACTION. Allocate the new transaction in
* POOL. */
-svn_error_t *svn_fs_fs__open_txn(svn_fs_txn_t **txn_p,
+svn_error_t *svn_fs_py__open_txn(svn_fs_txn_t **txn_p,
svn_fs_t *fs,
const char *name,
apr_pool_t *pool);
/* Return the property list from transaction TXN and store it in
*PROPLIST. Allocate the property list from POOL. */
-svn_error_t *svn_fs_fs__txn_proplist(apr_hash_t **proplist,
+svn_error_t *svn_fs_py__txn_proplist(apr_hash_t **proplist,
svn_fs_txn_t *txn,
apr_pool_t *pool);
/* Delete the mutable node-revision referenced by ID, along with any
mutable props or directory contents associated with it. Perform
temporary allocations in POOL. */
-svn_error_t *svn_fs_fs__delete_node_revision(svn_fs_t *fs,
+svn_error_t *svn_fs_py__delete_node_revision(svn_fs_t *fs,
const svn_fs_id_t *id,
apr_pool_t *pool);
@@ -384,7 +384,7 @@ svn_error_t *svn_fs_fs__delete_node_revi
/* Find the paths which were changed in transaction TXN_ID of
filesystem FS and store them in *CHANGED_PATHS_P.
Get any temporary allocations from POOL. */
-svn_error_t *svn_fs_fs__txn_changes_fetch(apr_hash_t **changes,
+svn_error_t *svn_fs_py__txn_changes_fetch(apr_hash_t **changes,
svn_fs_t *fs,
const char *txn_id,
apr_pool_t *pool);
@@ -399,7 +399,7 @@ svn_error_t *svn_fs_fs__txn_changes_fetc
call. If a file exists at that path, then it is correct; if not, then
the caller should call update_min_unpacked_rev() and re-try once. */
svn_error_t *
-svn_fs_fs__path_rev_absolute(const char **path,
+svn_fs_py__path_rev_absolute(const char **path,
svn_fs_t *fs,
svn_revnum_t rev,
apr_pool_t *pool);
@@ -407,13 +407,13 @@ svn_fs_fs__path_rev_absolute(const char
/* Return the path to the 'current' file in FS.
Perform allocation in POOL. */
const char *
-svn_fs_fs__path_current(svn_fs_t *fs, apr_pool_t *pool);
+svn_fs_py__path_current(svn_fs_t *fs, apr_pool_t *pool);
/* Obtain a write lock on the filesystem FS in a subpool of POOL, call
BODY with BATON and that subpool, destroy the subpool (releasing the write
lock) and return what BODY returned. */
svn_error_t *
-svn_fs_fs__with_write_lock(svn_fs_t *fs,
+svn_fs_py__with_write_lock(svn_fs_t *fs,
svn_error_t *(*body)(void *baton,
apr_pool_t *pool),
void *baton,
@@ -422,7 +422,7 @@ svn_fs_fs__with_write_lock(svn_fs_t *fs,
/* Find the value of the property named PROPNAME in transaction TXN.
Return the contents in *VALUE_P. The contents will be allocated
from POOL. */
-svn_error_t *svn_fs_fs__revision_prop(svn_string_t **value_p, svn_fs_t *fs,
+svn_error_t *svn_fs_py__revision_prop(svn_string_t **value_p, svn_fs_t *fs,
svn_revnum_t rev,
const char *propname,
apr_pool_t *pool);
@@ -432,7 +432,7 @@ svn_error_t *svn_fs_fs__revision_prop(sv
gives the new contents of the property. If value is NULL, then the
property will be deleted. If OLD_VALUE_P is not NULL, do nothing unless the
preexisting value is *OLD_VALUE_P. Do any temporary allocation in POOL. */
-svn_error_t *svn_fs_fs__change_rev_prop(svn_fs_t *fs, svn_revnum_t rev,
+svn_error_t *svn_fs_py__change_rev_prop(svn_fs_t *fs, svn_revnum_t rev,
const char *name,
const svn_string_t *const *old_value_p,
const svn_string_t *value,
@@ -451,7 +451,7 @@ svn_error_t *svn_fs_fs__change_rev_prop(
transaction that has already been committed.
Allocate *ROOT_ID_P and *BASE_ROOT_ID_P in POOL. */
-svn_error_t *svn_fs_fs__get_txn_ids(const svn_fs_id_t **root_id_p,
+svn_error_t *svn_fs_py__get_txn_ids(const svn_fs_id_t **root_id_p,
const svn_fs_id_t **base_root_id_p,
svn_fs_t *fs,
const char *txn_name,
@@ -460,19 +460,19 @@ svn_error_t *svn_fs_fs__get_txn_ids(cons
/* Begin a new transaction in filesystem FS, based on existing
revision REV. The new transaction is returned in *TXN_P. Allocate
the new transaction structure from POOL. */
-svn_error_t *svn_fs_fs__begin_txn(svn_fs_txn_t **txn_p, svn_fs_t *fs,
+svn_error_t *svn_fs_py__begin_txn(svn_fs_txn_t **txn_p, svn_fs_t *fs,
svn_revnum_t rev, apr_uint32_t flags,
apr_pool_t *pool);
/* Find the value of the property named PROPNAME in transaction TXN.
Return the contents in *VALUE_P. The contents will be allocated
from POOL. */
-svn_error_t *svn_fs_fs__txn_prop(svn_string_t **value_p, svn_fs_txn_t *txn,
+svn_error_t *svn_fs_py__txn_prop(svn_string_t **value_p, svn_fs_txn_t *txn,
const char *propname, apr_pool_t *pool);
/* If directory PATH does not exist, create it and give it the same
permissions as FS_PATH.*/
-svn_error_t *svn_fs_fs__ensure_dir_exists(const char *path,
+svn_error_t *svn_fs_py__ensure_dir_exists(const char *path,
const char *fs_path,
apr_pool_t *pool);
@@ -484,7 +484,7 @@ svn_error_t *svn_fs_fs__ensure_dir_exist
returns an error for other error conditions.
*/
svn_error_t *
-svn_fs_fs__set_node_origin(svn_fs_t *fs,
+svn_fs_py__set_node_origin(svn_fs_t *fs,
const char *node_id,
const svn_fs_id_t *node_rev_id,
apr_pool_t *pool);
@@ -497,7 +497,7 @@ svn_fs_fs__set_node_origin(svn_fs_t *fs,
If there is no entry for NODE_ID in the cache, return NULL
in *ORIGIN_ID. */
svn_error_t *
-svn_fs_fs__get_node_origin(const svn_fs_id_t **origin_id,
+svn_fs_py__get_node_origin(const svn_fs_id_t **origin_id,
svn_fs_t *fs,
const char *node_id,
apr_pool_t *pool);
@@ -509,7 +509,7 @@ svn_fs_fs__get_node_origin(const svn_fs_
Please note that it is permissible for this function to set some
or all of these caches to NULL, regardless of any setting. */
svn_error_t *
-svn_fs_fs__initialize_caches(svn_fs_t *fs, apr_pool_t *pool);
+svn_fs_py__initialize_caches(svn_fs_t *fs, apr_pool_t *pool);
/* Initialize all transaction-local caches in FS according to the global
cache settings and make TXN_ID part of their key space. Use POOL for
@@ -518,14 +518,14 @@ svn_fs_fs__initialize_caches(svn_fs_t *f
Please note that it is permissible for this function to set some or all
of these caches to NULL, regardless of any setting. */
svn_error_t *
-svn_fs_fs__initialize_txn_caches(svn_fs_t *fs,
+svn_fs_py__initialize_txn_caches(svn_fs_t *fs,
const char *txn_id,
apr_pool_t *pool);
/* Resets the svn_cache__t structures local to the current transaction in FS.
Calling it more than once per txn or from outside any txn is allowed. */
void
-svn_fs_fs__reset_txn_caches(svn_fs_t *fs);
+svn_fs_py__reset_txn_caches(svn_fs_t *fs);
/* Possibly pack the repository at PATH. This just take full shards, and
combines all the revision files into a single one, with a manifest header.
@@ -533,7 +533,7 @@ svn_fs_fs__reset_txn_caches(svn_fs_t *fs
Existing filesystem references need not change. */
svn_error_t *
-svn_fs_fs__pack(svn_fs_t *fs,
+svn_fs_py__pack(svn_fs_t *fs,
svn_fs_pack_notify_t notify_func,
void *notify_baton,
svn_cancel_func_t cancel_func,
Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/id.c
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/id.c?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/id.c (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/id.c Fri Aug 5 15:20:23 2011
@@ -40,7 +40,7 @@ typedef struct id_private_t {
/* Accessing ID Pieces. */
const char *
-svn_fs_fs__id_node_id(const svn_fs_id_t *id)
+svn_fs_py__id_node_id(const svn_fs_id_t *id)
{
id_private_t *pvt = id->fsap_data;
@@ -49,7 +49,7 @@ svn_fs_fs__id_node_id(const svn_fs_id_t
const char *
-svn_fs_fs__id_copy_id(const svn_fs_id_t *id)
+svn_fs_py__id_copy_id(const svn_fs_id_t *id)
{
id_private_t *pvt = id->fsap_data;
@@ -58,7 +58,7 @@ svn_fs_fs__id_copy_id(const svn_fs_id_t
const char *
-svn_fs_fs__id_txn_id(const svn_fs_id_t *id)
+svn_fs_py__id_txn_id(const svn_fs_id_t *id)
{
id_private_t *pvt = id->fsap_data;
@@ -67,7 +67,7 @@ svn_fs_fs__id_txn_id(const svn_fs_id_t *
svn_revnum_t
-svn_fs_fs__id_rev(const svn_fs_id_t *id)
+svn_fs_py__id_rev(const svn_fs_id_t *id)
{
id_private_t *pvt = id->fsap_data;
@@ -76,7 +76,7 @@ svn_fs_fs__id_rev(const svn_fs_id_t *id)
apr_off_t
-svn_fs_fs__id_offset(const svn_fs_id_t *id)
+svn_fs_py__id_offset(const svn_fs_id_t *id)
{
id_private_t *pvt = id->fsap_data;
@@ -85,7 +85,7 @@ svn_fs_fs__id_offset(const svn_fs_id_t *
svn_string_t *
-svn_fs_fs__id_unparse(const svn_fs_id_t *id,
+svn_fs_py__id_unparse(const svn_fs_id_t *id,
apr_pool_t *pool)
{
const char *txn_rev_id;
@@ -110,7 +110,7 @@ svn_fs_fs__id_unparse(const svn_fs_id_t
/*** Comparing node IDs ***/
svn_boolean_t
-svn_fs_fs__id_eq(const svn_fs_id_t *a,
+svn_fs_py__id_eq(const svn_fs_id_t *a,
const svn_fs_id_t *b)
{
id_private_t *pvta = a->fsap_data, *pvtb = b->fsap_data;
@@ -134,7 +134,7 @@ svn_fs_fs__id_eq(const svn_fs_id_t *a,
svn_boolean_t
-svn_fs_fs__id_check_related(const svn_fs_id_t *a,
+svn_fs_py__id_check_related(const svn_fs_id_t *a,
const svn_fs_id_t *b)
{
id_private_t *pvta = a->fsap_data, *pvtb = b->fsap_data;
@@ -155,12 +155,12 @@ svn_fs_fs__id_check_related(const svn_fs
int
-svn_fs_fs__id_compare(const svn_fs_id_t *a,
+svn_fs_py__id_compare(const svn_fs_id_t *a,
const svn_fs_id_t *b)
{
- if (svn_fs_fs__id_eq(a, b))
+ if (svn_fs_py__id_eq(a, b))
return 0;
- return (svn_fs_fs__id_check_related(a, b) ? 1 : -1);
+ return (svn_fs_py__id_check_related(a, b) ? 1 : -1);
}
@@ -168,13 +168,13 @@ svn_fs_fs__id_compare(const svn_fs_id_t
/* Creating ID's. */
static id_vtable_t id_vtable = {
- svn_fs_fs__id_unparse,
- svn_fs_fs__id_compare
+ svn_fs_py__id_unparse,
+ svn_fs_py__id_compare
};
svn_fs_id_t *
-svn_fs_fs__id_txn_create(const char *node_id,
+svn_fs_py__id_txn_create(const char *node_id,
const char *copy_id,
const char *txn_id,
apr_pool_t *pool)
@@ -195,7 +195,7 @@ svn_fs_fs__id_txn_create(const char *nod
svn_fs_id_t *
-svn_fs_fs__id_rev_create(const char *node_id,
+svn_fs_py__id_rev_create(const char *node_id,
const char *copy_id,
svn_revnum_t rev,
apr_off_t offset,
@@ -217,7 +217,7 @@ svn_fs_fs__id_rev_create(const char *nod
svn_fs_id_t *
-svn_fs_fs__id_copy(const svn_fs_id_t *id, apr_pool_t *pool)
+svn_fs_py__id_copy(const svn_fs_id_t *id, apr_pool_t *pool)
{
svn_fs_id_t *new_id = apr_palloc(pool, sizeof(*new_id));
id_private_t *new_pvt = apr_palloc(pool, sizeof(*new_pvt));
@@ -236,7 +236,7 @@ svn_fs_fs__id_copy(const svn_fs_id_t *id
svn_fs_id_t *
-svn_fs_fs__id_parse(const char *data,
+svn_fs_py__id_parse(const char *data,
apr_size_t len,
apr_pool_t *pool)
{
@@ -340,7 +340,7 @@ serialize_id_private(svn_temp_serializer
/* Serialize an ID within the serialization CONTEXT.
*/
void
-svn_fs_fs__id_serialize(svn_temp_serializer__context_t *context,
+svn_fs_py__id_serialize(svn_temp_serializer__context_t *context,
const struct svn_fs_id_t * const *id)
{
/* nothing to do for NULL ids */
@@ -379,7 +379,7 @@ deserialize_id_private(void *buffer, id_
/* Deserialize an ID inside the BUFFER.
*/
void
-svn_fs_fs__id_deserialize(void *buffer, svn_fs_id_t **id)
+svn_fs_py__id_deserialize(void *buffer, svn_fs_id_t **id)
{
/* The id maybe all what is in the whole buffer.
* Don't try to fixup the pointer in that case*/
Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/id.h
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/id.h?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/id.h (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/id.h Fri Aug 5 15:20:23 2011
@@ -33,60 +33,60 @@ extern "C" {
/*** ID accessor functions. ***/
/* Get the "node id" portion of ID. */
-const char *svn_fs_fs__id_node_id(const svn_fs_id_t *id);
+const char *svn_fs_py__id_node_id(const svn_fs_id_t *id);
/* Get the "copy id" portion of ID. */
-const char *svn_fs_fs__id_copy_id(const svn_fs_id_t *id);
+const char *svn_fs_py__id_copy_id(const svn_fs_id_t *id);
/* Get the "txn id" portion of ID, or NULL if it is a permanent ID. */
-const char *svn_fs_fs__id_txn_id(const svn_fs_id_t *id);
+const char *svn_fs_py__id_txn_id(const svn_fs_id_t *id);
/* Get the "rev" portion of ID, or SVN_INVALID_REVNUM if it is a
transaction ID. */
-svn_revnum_t svn_fs_fs__id_rev(const svn_fs_id_t *id);
+svn_revnum_t svn_fs_py__id_rev(const svn_fs_id_t *id);
/* Access the "offset" portion of the ID, or -1 if it is a transaction
ID. */
-apr_off_t svn_fs_fs__id_offset(const svn_fs_id_t *id);
+apr_off_t svn_fs_py__id_offset(const svn_fs_id_t *id);
/* Convert ID into string form, allocated in POOL. */
-svn_string_t *svn_fs_fs__id_unparse(const svn_fs_id_t *id,
+svn_string_t *svn_fs_py__id_unparse(const svn_fs_id_t *id,
apr_pool_t *pool);
/* Return true if A and B are equal. */
-svn_boolean_t svn_fs_fs__id_eq(const svn_fs_id_t *a,
+svn_boolean_t svn_fs_py__id_eq(const svn_fs_id_t *a,
const svn_fs_id_t *b);
/* Return true if A and B are related. */
-svn_boolean_t svn_fs_fs__id_check_related(const svn_fs_id_t *a,
+svn_boolean_t svn_fs_py__id_check_related(const svn_fs_id_t *a,
const svn_fs_id_t *b);
/* Return 0 if A and B are equal, 1 if they are related, -1 otherwise. */
-int svn_fs_fs__id_compare(const svn_fs_id_t *a,
+int svn_fs_py__id_compare(const svn_fs_id_t *a,
const svn_fs_id_t *b);
/* Create an ID within a transaction based on NODE_ID, COPY_ID, and
TXN_ID, allocated in POOL. */
-svn_fs_id_t *svn_fs_fs__id_txn_create(const char *node_id,
+svn_fs_id_t *svn_fs_py__id_txn_create(const char *node_id,
const char *copy_id,
const char *txn_id,
apr_pool_t *pool);
/* Create a permanent ID based on NODE_ID, COPY_ID, REV, and OFFSET,
allocated in POOL. */
-svn_fs_id_t *svn_fs_fs__id_rev_create(const char *node_id,
+svn_fs_id_t *svn_fs_py__id_rev_create(const char *node_id,
const char *copy_id,
svn_revnum_t rev,
apr_off_t offset,
apr_pool_t *pool);
/* Return a copy of ID, allocated from POOL. */
-svn_fs_id_t *svn_fs_fs__id_copy(const svn_fs_id_t *id,
+svn_fs_id_t *svn_fs_py__id_copy(const svn_fs_id_t *id,
apr_pool_t *pool);
/* Return an ID resulting from parsing the string DATA (with length
LEN), or NULL if DATA is an invalid ID string. */
-svn_fs_id_t *svn_fs_fs__id_parse(const char *data,
+svn_fs_id_t *svn_fs_py__id_parse(const char *data,
apr_size_t len,
apr_pool_t *pool);
@@ -99,14 +99,14 @@ struct svn_temp_serializer__context_t;
* Serialize an @a id within the serialization @a context.
*/
void
-svn_fs_fs__id_serialize(struct svn_temp_serializer__context_t *context,
+svn_fs_py__id_serialize(struct svn_temp_serializer__context_t *context,
const svn_fs_id_t * const *id);
/**
* Deserialize an @a id within the @a buffer.
*/
void
-svn_fs_fs__id_deserialize(void *buffer,
+svn_fs_py__id_deserialize(void *buffer,
svn_fs_id_t **id);
#ifdef __cplusplus
Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/key-gen.c
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/key-gen.c?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/key-gen.c (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/key-gen.c Fri Aug 5 15:20:23 2011
@@ -39,7 +39,7 @@
/*** Keys for reps and strings. ***/
void
-svn_fs_fs__add_keys(const char *key1, const char *key2, char *result)
+svn_fs_py__add_keys(const char *key1, const char *key2, char *result)
{
int i1 = strlen(key1) - 1;
int i2 = strlen(key2) - 1;
@@ -77,7 +77,7 @@ svn_fs_fs__add_keys(const char *key1, co
void
-svn_fs_fs__next_key(const char *this, apr_size_t *len, char *next)
+svn_fs_py__next_key(const char *this, apr_size_t *len, char *next)
{
int i;
apr_size_t olen = *len; /* remember the first length */
@@ -144,7 +144,7 @@ svn_fs_fs__next_key(const char *this, ap
int
-svn_fs_fs__key_compare(const char *a, const char *b)
+svn_fs_py__key_compare(const char *a, const char *b)
{
int a_len = strlen(a);
int b_len = strlen(b);
Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/key-gen.h
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/key-gen.h?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/key-gen.h (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/key-gen.h Fri Aug 5 15:20:23 2011
@@ -32,7 +32,7 @@ extern "C" {
#endif /* __cplusplus */
-/* The alphanumeric keys passed in and out of svn_fs_fs__next_key
+/* The alphanumeric keys passed in and out of svn_fs_py__next_key
are guaranteed never to be longer than this many bytes,
*including* the trailing null byte. It is therefore safe
to declare a key as "char key[MAX_KEY_SIZE]".
@@ -70,7 +70,7 @@ extern "C" {
* string "0", then *LEN is set to zero and the effect on NEXT
* is undefined.
*/
-void svn_fs_fs__next_key(const char *this, apr_size_t *len, char *next);
+void svn_fs_py__next_key(const char *this, apr_size_t *len, char *next);
/* Compare two strings A and B as base-36 alphanumeric keys.
@@ -78,10 +78,10 @@ void svn_fs_fs__next_key(const char *thi
* Return -1, 0, or 1 if A is less than, equal to, or greater than B,
* respectively.
*/
-int svn_fs_fs__key_compare(const char *a, const char *b);
+int svn_fs_py__key_compare(const char *a, const char *b);
/* Add two base-36 alphanumeric keys to get a third, the result. */
-void svn_fs_fs__add_keys(const char *key1, const char *key2, char *result);
+void svn_fs_py__add_keys(const char *key1, const char *key2, char *result);
#ifdef __cplusplus
Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/lock.c
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/lock.c?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/lock.c (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/lock.c Fri Aug 5 15:20:23 2011
@@ -176,9 +176,9 @@ write_digest_file(apr_hash_t *children,
apr_hash_t *hash = apr_hash_make(pool);
const char *tmp_path;
- SVN_ERR(svn_fs_fs__ensure_dir_exists(svn_dirent_join(fs_path, PATH_LOCKS_DIR,
+ SVN_ERR(svn_fs_py__ensure_dir_exists(svn_dirent_join(fs_path, PATH_LOCKS_DIR,
pool), fs_path, pool));
- SVN_ERR(svn_fs_fs__ensure_dir_exists(svn_dirent_dirname(digest_path, pool),
+ SVN_ERR(svn_fs_py__ensure_dir_exists(svn_dirent_dirname(digest_path, pool),
fs_path, pool));
if (lock)
@@ -459,7 +459,7 @@ delete_lock(svn_fs_t *fs,
else
{
const char *rev_0_path;
- SVN_ERR(svn_fs_fs__path_rev_absolute(&rev_0_path, fs, 0, pool));
+ SVN_ERR(svn_fs_py__path_rev_absolute(&rev_0_path, fs, 0, pool));
SVN_ERR(write_digest_file(this_children, this_lock, fs->path,
digest_path, rev_0_path, subpool));
}
@@ -703,7 +703,7 @@ get_locks_callback(void *baton,
/* The main routine for lock enforcement, used throughout libsvn_fs_fs. */
svn_error_t *
-svn_fs_fs__allow_locked_operation(const char *path,
+svn_fs_py__allow_locked_operation(const char *path,
svn_fs_t *fs,
svn_boolean_t recurse,
svn_boolean_t have_write_lock,
@@ -744,7 +744,7 @@ struct lock_baton {
};
-/* This implements the svn_fs_fs__with_write_lock() 'body' callback
+/* This implements the svn_fs_py__with_write_lock() 'body' callback
type, and assumes that the write lock is held.
BATON is a 'struct lock_baton *'. */
static svn_error_t *
@@ -764,7 +764,7 @@ lock_body(void *baton, apr_pool_t *pool)
library dependencies, which are not portable. */
SVN_ERR(lb->fs->vtable->youngest_rev(&youngest, lb->fs, pool));
SVN_ERR(lb->fs->vtable->revision_root(&root, lb->fs, youngest, pool));
- SVN_ERR(svn_fs_fs__check_path(&kind, root, lb->path, pool));
+ SVN_ERR(svn_fs_py__check_path(&kind, root, lb->path, pool));
if (kind == svn_node_dir)
return SVN_FS__ERR_NOT_FILE(lb->fs, lb->path, pool);
@@ -792,7 +792,7 @@ lock_body(void *baton, apr_pool_t *pool)
if (SVN_IS_VALID_REVNUM(lb->current_rev))
{
svn_revnum_t created_rev;
- SVN_ERR(svn_fs_fs__node_created_rev(&created_rev, root, lb->path,
+ SVN_ERR(svn_fs_py__node_created_rev(&created_rev, root, lb->path,
pool));
/* SVN_INVALID_REVNUM means the path doesn't exist. So
@@ -848,7 +848,7 @@ lock_body(void *baton, apr_pool_t *pool)
if (lb->token)
lock->token = apr_pstrdup(lb->pool, lb->token);
else
- SVN_ERR(svn_fs_fs__generate_lock_token(&(lock->token), lb->fs,
+ SVN_ERR(svn_fs_py__generate_lock_token(&(lock->token), lb->fs,
lb->pool));
lock->path = apr_pstrdup(lb->pool, lb->path);
lock->owner = apr_pstrdup(lb->pool, lb->fs->access_ctx->username);
@@ -856,7 +856,7 @@ lock_body(void *baton, apr_pool_t *pool)
lock->is_dav_comment = lb->is_dav_comment;
lock->creation_date = apr_time_now();
lock->expiration_date = lb->expiration_date;
- SVN_ERR(svn_fs_fs__path_rev_absolute(&rev_0_path, lb->fs, 0, pool));
+ SVN_ERR(svn_fs_py__path_rev_absolute(&rev_0_path, lb->fs, 0, pool));
SVN_ERR(set_lock(lb->fs->path, lock, rev_0_path, pool));
*lb->lock_p = lock;
@@ -871,7 +871,7 @@ struct unlock_baton {
svn_boolean_t break_lock;
};
-/* This implements the svn_fs_fs__with_write_lock() 'body' callback
+/* This implements the svn_fs_py__with_write_lock() 'body' callback
type, and assumes that the write lock is held.
BATON is a 'struct unlock_baton *'. */
static svn_error_t *
@@ -908,7 +908,7 @@ unlock_body(void *baton, apr_pool_t *poo
/*** Public API implementations ***/
svn_error_t *
-svn_fs_fs__lock(svn_lock_t **lock_p,
+svn_fs_py__lock(svn_lock_t **lock_p,
svn_fs_t *fs,
const char *path,
const char *token,
@@ -935,12 +935,12 @@ svn_fs_fs__lock(svn_lock_t **lock_p,
lb.steal_lock = steal_lock;
lb.pool = pool;
- return svn_fs_fs__with_write_lock(fs, lock_body, &lb, pool);
+ return svn_fs_py__with_write_lock(fs, lock_body, &lb, pool);
}
svn_error_t *
-svn_fs_fs__generate_lock_token(const char **token,
+svn_fs_py__generate_lock_token(const char **token,
svn_fs_t *fs,
apr_pool_t *pool)
{
@@ -957,7 +957,7 @@ svn_fs_fs__generate_lock_token(const cha
svn_error_t *
-svn_fs_fs__unlock(svn_fs_t *fs,
+svn_fs_py__unlock(svn_fs_t *fs,
const char *path,
const char *token,
svn_boolean_t break_lock,
@@ -973,12 +973,12 @@ svn_fs_fs__unlock(svn_fs_t *fs,
ub.token = token;
ub.break_lock = break_lock;
- return svn_fs_fs__with_write_lock(fs, unlock_body, &ub, pool);
+ return svn_fs_py__with_write_lock(fs, unlock_body, &ub, pool);
}
svn_error_t *
-svn_fs_fs__get_lock(svn_lock_t **lock_p,
+svn_fs_py__get_lock(svn_lock_t **lock_p,
svn_fs_t *fs,
const char *path,
apr_pool_t *pool)
@@ -1000,7 +1000,7 @@ typedef struct get_locks_filter_baton_t
} get_locks_filter_baton_t;
-/* A wrapper for the GET_LOCKS_FUNC passed to svn_fs_fs__get_locks()
+/* A wrapper for the GET_LOCKS_FUNC passed to svn_fs_py__get_locks()
which filters out locks on paths that aren't within
BATON->requested_depth of BATON->path before called
BATON->get_locks_func() with BATON->get_locks_baton.
@@ -1010,7 +1010,7 @@ typedef struct get_locks_filter_baton_t
resolved, we take this filtering approach rather than honoring
depth requests closer to the crawling code. In other words, once
we decide how to resolve issue #3660, there might be a more
- performant way to honor the depth passed to svn_fs_fs__get_locks(). */
+ performant way to honor the depth passed to svn_fs_py__get_locks(). */
static svn_error_t *
get_locks_filter_func(void *baton,
svn_lock_t *lock,
@@ -1045,7 +1045,7 @@ get_locks_filter_func(void *baton,
}
svn_error_t *
-svn_fs_fs__get_locks(svn_fs_t *fs,
+svn_fs_py__get_locks(svn_fs_t *fs,
const char *path,
svn_depth_t depth,
svn_fs_get_locks_callback_t get_locks_func,
Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/lock.h
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/lock.h?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/lock.h (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/lock.h Fri Aug 5 15:20:23 2011
@@ -32,7 +32,7 @@ extern "C" {
/* These functions implement some of the calls in the FS loader
library's fs vtables. */
-svn_error_t *svn_fs_fs__lock(svn_lock_t **lock,
+svn_error_t *svn_fs_py__lock(svn_lock_t **lock,
svn_fs_t *fs,
const char *path,
const char *token,
@@ -43,22 +43,22 @@ svn_error_t *svn_fs_fs__lock(svn_lock_t
svn_boolean_t steal_lock,
apr_pool_t *pool);
-svn_error_t *svn_fs_fs__generate_lock_token(const char **token,
+svn_error_t *svn_fs_py__generate_lock_token(const char **token,
svn_fs_t *fs,
apr_pool_t *pool);
-svn_error_t *svn_fs_fs__unlock(svn_fs_t *fs,
+svn_error_t *svn_fs_py__unlock(svn_fs_t *fs,
const char *path,
const char *token,
svn_boolean_t break_lock,
apr_pool_t *pool);
-svn_error_t *svn_fs_fs__get_lock(svn_lock_t **lock,
+svn_error_t *svn_fs_py__get_lock(svn_lock_t **lock,
svn_fs_t *fs,
const char *path,
apr_pool_t *pool);
-svn_error_t *svn_fs_fs__get_locks(svn_fs_t *fs,
+svn_error_t *svn_fs_py__get_locks(svn_fs_t *fs,
const char *path,
svn_depth_t depth,
svn_fs_get_locks_callback_t get_locks_func,
@@ -90,7 +90,7 @@ svn_error_t *svn_fs_fs__get_locks(svn_fs
If the caller (directly or indirectly) has the FS write lock,
HAVE_WRITE_LOCK should be true.
*/
-svn_error_t *svn_fs_fs__allow_locked_operation(const char *path,
+svn_error_t *svn_fs_py__allow_locked_operation(const char *path,
svn_fs_t *fs,
svn_boolean_t recurse,
svn_boolean_t have_write_lock,
Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/rep-cache.c
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/rep-cache.c?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/rep-cache.c (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/rep-cache.c Fri Aug 5 15:20:23 2011
@@ -65,7 +65,7 @@ rep_has_been_born(representation_t *rep,
if (youngest < rep->revision)
{
/* Stale cache. */
- SVN_ERR(svn_fs_fs__youngest_rev(&youngest, fs, pool));
+ SVN_ERR(svn_fs_py__youngest_rev(&youngest, fs, pool));
/* Fresh cache. */
if (youngest < rep->revision)
@@ -82,7 +82,7 @@ rep_has_been_born(representation_t *rep,
/** Library-private API's. **/
-/* Body of svn_fs_fs__open_rep_cache().
+/* Body of svn_fs_py__open_rep_cache().
Implements svn_atomic__init_once().init_func.
*/
static svn_error_t *
@@ -115,7 +115,7 @@ open_rep_cache(void *baton,
}
svn_error_t *
-svn_fs_fs__open_rep_cache(svn_fs_t *fs,
+svn_fs_py__open_rep_cache(svn_fs_t *fs,
apr_pool_t *pool)
{
fs_fs_data_t *ffd = fs->fsap_data;
@@ -125,7 +125,7 @@ svn_fs_fs__open_rep_cache(svn_fs_t *fs,
}
svn_error_t *
-svn_fs_fs__exists_rep_cache(svn_boolean_t *exists,
+svn_fs_py__exists_rep_cache(svn_boolean_t *exists,
svn_fs_t *fs, apr_pool_t *pool)
{
svn_node_kind_t kind;
@@ -138,7 +138,7 @@ svn_fs_fs__exists_rep_cache(svn_boolean_
}
svn_error_t *
-svn_fs_fs__walk_rep_reference(svn_fs_t *fs,
+svn_fs_py__walk_rep_reference(svn_fs_t *fs,
svn_error_t *(*walker)(representation_t *,
void *,
svn_fs_t *,
@@ -159,7 +159,7 @@ svn_fs_fs__walk_rep_reference(svn_fs_t *
SVN_ERR_ASSERT(ffd->format >= SVN_FS_FS__MIN_REP_SHARING_FORMAT);
if (! ffd->rep_cache_db)
- SVN_ERR(svn_fs_fs__open_rep_cache(fs, pool));
+ SVN_ERR(svn_fs_py__open_rep_cache(fs, pool));
/* Get the statement. (There are no arguments to bind.) */
SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db,
@@ -212,7 +212,7 @@ svn_fs_fs__walk_rep_reference(svn_fs_t *
If you extend this function, check the callsite to see if you have
to make it not-ignore additional error codes. */
svn_error_t *
-svn_fs_fs__get_rep_reference(representation_t **rep,
+svn_fs_py__get_rep_reference(representation_t **rep,
svn_fs_t *fs,
svn_checksum_t *checksum,
apr_pool_t *pool)
@@ -223,7 +223,7 @@ svn_fs_fs__get_rep_reference(representat
SVN_ERR_ASSERT(ffd->rep_sharing_allowed);
if (! ffd->rep_cache_db)
- SVN_ERR(svn_fs_fs__open_rep_cache(fs, pool));
+ SVN_ERR(svn_fs_py__open_rep_cache(fs, pool));
/* We only allow SHA1 checksums in this table. */
if (checksum->kind != svn_checksum_sha1)
@@ -255,7 +255,7 @@ svn_fs_fs__get_rep_reference(representat
}
svn_error_t *
-svn_fs_fs__set_rep_reference(svn_fs_t *fs,
+svn_fs_py__set_rep_reference(svn_fs_t *fs,
representation_t *rep,
svn_boolean_t reject_dup,
apr_pool_t *pool)
@@ -266,7 +266,7 @@ svn_fs_fs__set_rep_reference(svn_fs_t *f
SVN_ERR_ASSERT(ffd->rep_sharing_allowed);
if (! ffd->rep_cache_db)
- SVN_ERR(svn_fs_fs__open_rep_cache(fs, pool));
+ SVN_ERR(svn_fs_py__open_rep_cache(fs, pool));
/* We only allow SHA1 checksums in this table. */
if (rep->sha1_checksum == NULL)
@@ -296,7 +296,7 @@ svn_fs_fs__set_rep_reference(svn_fs_t *f
should exist. If so, and the value is the same one we were
about to write, that's cool -- just do nothing. If, however,
the value is *different*, that's a red flag! */
- SVN_ERR(svn_fs_fs__get_rep_reference(&old_rep, fs, rep->sha1_checksum,
+ SVN_ERR(svn_fs_py__get_rep_reference(&old_rep, fs, rep->sha1_checksum,
pool));
if (old_rep)
Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/rep-cache.h
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/rep-cache.h?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/rep-cache.h (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/rep-cache.h Fri Aug 5 15:20:23 2011
@@ -37,17 +37,17 @@ extern "C" {
/* Open and create, if needed, the rep cache database associated with FS.
Use POOL for temporary allocations. */
svn_error_t *
-svn_fs_fs__open_rep_cache(svn_fs_t *fs,
+svn_fs_py__open_rep_cache(svn_fs_t *fs,
apr_pool_t *pool);
/* Set *EXISTS to TRUE iff the rep-cache DB file exists. */
svn_error_t *
-svn_fs_fs__exists_rep_cache(svn_boolean_t *exists,
+svn_fs_py__exists_rep_cache(svn_boolean_t *exists,
svn_fs_t *fs, apr_pool_t *pool);
/* Iterate all representations currently in FS's cache. */
svn_error_t *
-svn_fs_fs__walk_rep_reference(svn_fs_t *fs,
+svn_fs_py__walk_rep_reference(svn_fs_t *fs,
svn_error_t *(*walker)(representation_t *rep,
void *walker_baton,
svn_fs_t *fs,
@@ -61,7 +61,7 @@ svn_fs_fs__walk_rep_reference(svn_fs_t *
REP is allocated in POOL. If the rep cache database has not been
opened, just set *REP to NULL. */
svn_error_t *
-svn_fs_fs__get_rep_reference(representation_t **rep,
+svn_fs_py__get_rep_reference(representation_t **rep,
svn_fs_t *fs,
svn_checksum_t *checksum,
apr_pool_t *pool);
@@ -74,7 +74,7 @@ svn_fs_fs__get_rep_reference(representat
If REJECT_DUP is TRUE, return an error if there is an existing
match for REP->CHECKSUM. */
svn_error_t *
-svn_fs_fs__set_rep_reference(svn_fs_t *fs,
+svn_fs_py__set_rep_reference(svn_fs_t *fs,
representation_t *rep,
svn_boolean_t reject_dup,
apr_pool_t *pool);
Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/temp_serializer.c
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/temp_serializer.c?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/temp_serializer.c (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/temp_serializer.c Fri Aug 5 15:20:23 2011
@@ -69,7 +69,7 @@ encode_number(apr_int64_t number, char *
* Allocate temporaries as well as the result from POOL.
*/
const char*
-svn_fs_fs__combine_number_and_string(apr_int64_t number,
+svn_fs_py__combine_number_and_string(apr_int64_t number,
const char *string,
apr_pool_t *pool)
{
@@ -96,7 +96,7 @@ svn_fs_fs__combine_number_and_string(apr
* Allocate temporaries as well as the result from POOL.
*/
const char*
-svn_fs_fs__combine_two_numbers(apr_int64_t a,
+svn_fs_py__combine_two_numbers(apr_int64_t a,
apr_int64_t b,
apr_pool_t *pool)
{
@@ -291,7 +291,7 @@ serialize_dir_entry(svn_temp_serializer_
(const void * const *)entry_p,
sizeof(svn_fs_dirent_t));
- svn_fs_fs__id_serialize(context, &entry->id);
+ svn_fs_py__id_serialize(context, &entry->id);
svn_temp_serializer__add_string(context, &entry->name);
*length = (apr_uint32_t)( svn_temp_serializer__get_length(context)
@@ -385,7 +385,7 @@ deserialize_dir(void *buffer, hash_data_
/* pointer fixup */
svn_temp_deserializer__resolve(entry, (void **)&entry->name);
- svn_fs_fs__id_deserialize(entry, (svn_fs_id_t **)&entry->id);
+ svn_fs_py__id_deserialize(entry, (svn_fs_id_t **)&entry->id);
/* add the entry to the hash */
apr_hash_set(result, entry->name, APR_HASH_KEY_STRING, entry);
@@ -396,7 +396,7 @@ deserialize_dir(void *buffer, hash_data_
}
void
-svn_fs_fs__noderev_serialize(svn_temp_serializer__context_t *context,
+svn_fs_py__noderev_serialize(svn_temp_serializer__context_t *context,
node_revision_t * const *noderev_p)
{
const node_revision_t *noderev = *noderev_p;
@@ -409,8 +409,8 @@ svn_fs_fs__noderev_serialize(svn_temp_se
sizeof(*noderev));
/* serialize sub-structures */
- svn_fs_fs__id_serialize(context, &noderev->id);
- svn_fs_fs__id_serialize(context, &noderev->predecessor_id);
+ svn_fs_py__id_serialize(context, &noderev->id);
+ svn_fs_py__id_serialize(context, &noderev->predecessor_id);
serialize_representation(context, &noderev->prop_rep);
serialize_representation(context, &noderev->data_rep);
@@ -424,7 +424,7 @@ svn_fs_fs__noderev_serialize(svn_temp_se
void
-svn_fs_fs__noderev_deserialize(void *buffer,
+svn_fs_py__noderev_deserialize(void *buffer,
node_revision_t **noderev_p)
{
node_revision_t *noderev;
@@ -439,8 +439,8 @@ svn_fs_fs__noderev_deserialize(void *buf
return;
/* fixup of sub-structures */
- svn_fs_fs__id_deserialize(noderev, (svn_fs_id_t **)&noderev->id);
- svn_fs_fs__id_deserialize(noderev, (svn_fs_id_t **)&noderev->predecessor_id);
+ svn_fs_py__id_deserialize(noderev, (svn_fs_id_t **)&noderev->id);
+ svn_fs_py__id_deserialize(noderev, (svn_fs_id_t **)&noderev->predecessor_id);
deserialize_representation(noderev, &noderev->prop_rep);
deserialize_representation(noderev, &noderev->data_rep);
@@ -489,12 +489,12 @@ serialize_txdeltawindow(svn_temp_seriali
}
svn_error_t *
-svn_fs_fs__serialize_txdelta_window(char **buffer,
+svn_fs_py__serialize_txdelta_window(char **buffer,
apr_size_t *buffer_size,
void *item,
apr_pool_t *pool)
{
- svn_fs_fs__txdelta_cached_window_t *window_info = item;
+ svn_fs_py__txdelta_cached_window_t *window_info = item;
svn_stringbuf_t *serialized;
/* initialize the serialization process and allocate a buffer large
@@ -521,7 +521,7 @@ svn_fs_fs__serialize_txdelta_window(char
}
svn_error_t *
-svn_fs_fs__deserialize_txdelta_window(void **item,
+svn_fs_py__deserialize_txdelta_window(void **item,
char *buffer,
apr_size_t buffer_size,
apr_pool_t *pool)
@@ -529,8 +529,8 @@ svn_fs_fs__deserialize_txdelta_window(vo
svn_txdelta_window_t *window;
/* Copy the _full_ buffer as it also contains the sub-structures. */
- svn_fs_fs__txdelta_cached_window_t *window_info =
- (svn_fs_fs__txdelta_cached_window_t *)buffer;
+ svn_fs_py__txdelta_cached_window_t *window_info =
+ (svn_fs_py__txdelta_cached_window_t *)buffer;
/* pointer reference fixup */
svn_temp_deserializer__resolve(window_info,
@@ -548,7 +548,7 @@ svn_fs_fs__deserialize_txdelta_window(vo
}
svn_error_t *
-svn_fs_fs__serialize_manifest(char **data,
+svn_fs_py__serialize_manifest(char **data,
apr_size_t *data_len,
void *in,
apr_pool_t *pool)
@@ -563,7 +563,7 @@ svn_fs_fs__serialize_manifest(char **dat
}
svn_error_t *
-svn_fs_fs__deserialize_manifest(void **out,
+svn_fs_py__deserialize_manifest(void **out,
char *data,
apr_size_t data_len,
apr_pool_t *pool)
@@ -580,7 +580,7 @@ svn_fs_fs__deserialize_manifest(void **o
}
svn_error_t *
-svn_fs_fs__serialize_id(char **data,
+svn_fs_py__serialize_id(char **data,
apr_size_t *data_len,
void *in,
apr_pool_t *pool)
@@ -593,7 +593,7 @@ svn_fs_fs__serialize_id(char **data,
svn_temp_serializer__init(NULL, 0, 250, pool);
/* serialize the id */
- svn_fs_fs__id_serialize(context, &id);
+ svn_fs_py__id_serialize(context, &id);
/* return serialized data */
serialized = svn_temp_serializer__get(context);
@@ -604,7 +604,7 @@ svn_fs_fs__serialize_id(char **data,
}
svn_error_t *
-svn_fs_fs__deserialize_id(void **out,
+svn_fs_py__deserialize_id(void **out,
char *data,
apr_size_t data_len,
apr_pool_t *pool)
@@ -613,7 +613,7 @@ svn_fs_fs__deserialize_id(void **out,
svn_fs_id_t *id = (svn_fs_id_t *)data;
/* fixup of all pointers etc. */
- svn_fs_fs__id_deserialize(id, &id);
+ svn_fs_py__id_deserialize(id, &id);
/* done */
*out = id;
@@ -623,7 +623,7 @@ svn_fs_fs__deserialize_id(void **out,
/** Caching node_revision_t objects. **/
svn_error_t *
-svn_fs_fs__serialize_node_revision(char **buffer,
+svn_fs_py__serialize_node_revision(char **buffer,
apr_size_t *buffer_size,
void *item,
apr_pool_t *pool)
@@ -636,7 +636,7 @@ svn_fs_fs__serialize_node_revision(char
svn_temp_serializer__init(NULL, 0, 503, pool);
/* serialize the noderev */
- svn_fs_fs__noderev_serialize(context, &noderev);
+ svn_fs_py__noderev_serialize(context, &noderev);
/* return serialized data */
serialized = svn_temp_serializer__get(context);
@@ -647,7 +647,7 @@ svn_fs_fs__serialize_node_revision(char
}
svn_error_t *
-svn_fs_fs__deserialize_node_revision(void **item,
+svn_fs_py__deserialize_node_revision(void **item,
char *buffer,
apr_size_t buffer_size,
apr_pool_t *pool)
@@ -656,7 +656,7 @@ svn_fs_fs__deserialize_node_revision(voi
node_revision_t *noderev = (node_revision_t *)buffer;
/* fixup of all pointers etc. */
- svn_fs_fs__noderev_deserialize(noderev, &noderev);
+ svn_fs_py__noderev_deserialize(noderev, &noderev);
/* done */
*item = noderev;
@@ -680,7 +680,7 @@ return_serialized_dir_context(svn_temp_s
}
svn_error_t *
-svn_fs_fs__serialize_dir_entries(char **data,
+svn_fs_py__serialize_dir_entries(char **data,
apr_size_t *data_len,
void *in,
apr_pool_t *pool)
@@ -695,7 +695,7 @@ svn_fs_fs__serialize_dir_entries(char **
}
svn_error_t *
-svn_fs_fs__deserialize_dir_entries(void **out,
+svn_fs_py__deserialize_dir_entries(void **out,
char *data,
apr_size_t data_len,
apr_pool_t *pool)
@@ -710,7 +710,7 @@ svn_fs_fs__deserialize_dir_entries(void
}
svn_error_t *
-svn_fs_fs__get_sharded_offset(void **out,
+svn_fs_py__get_sharded_offset(void **out,
const char *data,
apr_size_t data_len,
void *baton,
@@ -771,7 +771,7 @@ find_entry(svn_fs_dirent_t **entries,
}
svn_error_t *
-svn_fs_fs__extract_dir_entry(void **out,
+svn_fs_py__extract_dir_entry(void **out,
const char *data,
apr_size_t data_len,
void *baton,
@@ -814,14 +814,14 @@ svn_fs_fs__extract_dir_entry(void **out,
memcpy(new_entry, source, size);
svn_temp_deserializer__resolve(new_entry, (void **)&new_entry->name);
- svn_fs_fs__id_deserialize(new_entry, (svn_fs_id_t **)&new_entry->id);
+ svn_fs_py__id_deserialize(new_entry, (svn_fs_id_t **)&new_entry->id);
*(svn_fs_dirent_t **)out = new_entry;
}
return SVN_NO_ERROR;
}
-/* Utility function for svn_fs_fs__replace_dir_entry that implements the
+/* Utility function for svn_fs_py__replace_dir_entry that implements the
* modification as a simply deserialize / modify / serialize sequence.
*/
static svn_error_t *
@@ -834,7 +834,7 @@ slowly_replace_dir_entry(char **data,
hash_data_t *hash_data = (hash_data_t *)*data;
apr_hash_t *dir;
- SVN_ERR(svn_fs_fs__deserialize_dir_entries((void **)&dir,
+ SVN_ERR(svn_fs_py__deserialize_dir_entries((void **)&dir,
*data,
hash_data->len,
pool));
@@ -843,11 +843,11 @@ slowly_replace_dir_entry(char **data,
APR_HASH_KEY_STRING,
replace_baton->new_entry);
- return svn_fs_fs__serialize_dir_entries(data, data_len, dir, pool);
+ return svn_fs_py__serialize_dir_entries(data, data_len, dir, pool);
}
svn_error_t *
-svn_fs_fs__replace_dir_entry(char **data,
+svn_fs_py__replace_dir_entry(char **data,
apr_size_t *data_len,
void *baton,
apr_pool_t *pool)
Modified: subversion/branches/fs-py/subversion/libsvn_fs_py/temp_serializer.h
URL: http://svn.apache.org/viewvc/subversion/branches/fs-py/subversion/libsvn_fs_py/temp_serializer.h?rev=1154262&r1=1154224&r2=1154262&view=diff
==============================================================================
--- subversion/branches/fs-py/subversion/libsvn_fs_py/temp_serializer.h (original)
+++ subversion/branches/fs-py/subversion/libsvn_fs_py/temp_serializer.h Fri Aug 5 15:20:23 2011
@@ -31,7 +31,7 @@
* Allocate temporaries as well as the result from @a pool.
*/
const char*
-svn_fs_fs__combine_number_and_string(apr_int64_t number,
+svn_fs_py__combine_number_and_string(apr_int64_t number,
const char *string,
apr_pool_t *pool);
@@ -41,7 +41,7 @@ svn_fs_fs__combine_number_and_string(apr
* Allocate temporaries as well as the result from @a pool.
*/
const char*
-svn_fs_fs__combine_two_numbers(apr_int64_t a,
+svn_fs_py__combine_two_numbers(apr_int64_t a,
apr_int64_t b,
apr_pool_t *pool);
@@ -49,14 +49,14 @@ svn_fs_fs__combine_two_numbers(apr_int64
* Serialize a @a noderev_p within the serialization @a context.
*/
void
-svn_fs_fs__noderev_serialize(struct svn_temp_serializer__context_t *context,
+svn_fs_py__noderev_serialize(struct svn_temp_serializer__context_t *context,
node_revision_t * const *noderev_p);
/**
* Deserialize a @a noderev_p within the @a buffer.
*/
void
-svn_fs_fs__noderev_deserialize(void *buffer,
+svn_fs_py__noderev_deserialize(void *buffer,
node_revision_t **noderev_p);
/**
@@ -70,24 +70,24 @@ typedef struct
/* the revision file read pointer position right after reading the window */
apr_off_t end_offset;
-} svn_fs_fs__txdelta_cached_window_t;
+} svn_fs_py__txdelta_cached_window_t;
/**
* Implements #svn_cache__serialize_func_t for
- * #svn_fs_fs__txdelta_cached_window_t.
+ * #svn_fs_py__txdelta_cached_window_t.
*/
svn_error_t *
-svn_fs_fs__serialize_txdelta_window(char **buffer,
+svn_fs_py__serialize_txdelta_window(char **buffer,
apr_size_t *buffer_size,
void *item,
apr_pool_t *pool);
/**
* Implements #svn_cache__deserialize_func_t for
- * #svn_fs_fs__txdelta_cached_window_t.
+ * #svn_fs_py__txdelta_cached_window_t.
*/
svn_error_t *
-svn_fs_fs__deserialize_txdelta_window(void **item,
+svn_fs_py__deserialize_txdelta_window(void **item,
char *buffer,
apr_size_t buffer_size,
apr_pool_t *pool);
@@ -97,7 +97,7 @@ svn_fs_fs__deserialize_txdelta_window(vo
* (@a in is an #apr_array_header_t of apr_off_t elements).
*/
svn_error_t *
-svn_fs_fs__serialize_manifest(char **data,
+svn_fs_py__serialize_manifest(char **data,
apr_size_t *data_len,
void *in,
apr_pool_t *pool);
@@ -107,7 +107,7 @@ svn_fs_fs__serialize_manifest(char **dat
* (@a *out is an #apr_array_header_t of apr_off_t elements).
*/
svn_error_t *
-svn_fs_fs__deserialize_manifest(void **out,
+svn_fs_py__deserialize_manifest(void **out,
char *data,
apr_size_t data_len,
apr_pool_t *pool);
@@ -116,7 +116,7 @@ svn_fs_fs__deserialize_manifest(void **o
* Implements #svn_cache__serialize_func_t for #svn_fs_id_t
*/
svn_error_t *
-svn_fs_fs__serialize_id(char **data,
+svn_fs_py__serialize_id(char **data,
apr_size_t *data_len,
void *in,
apr_pool_t *pool);
@@ -125,7 +125,7 @@ svn_fs_fs__serialize_id(char **data,
* Implements #svn_cache__deserialize_func_t for #svn_fs_id_t
*/
svn_error_t *
-svn_fs_fs__deserialize_id(void **out,
+svn_fs_py__deserialize_id(void **out,
char *data,
apr_size_t data_len,
apr_pool_t *pool);
@@ -134,7 +134,7 @@ svn_fs_fs__deserialize_id(void **out,
* Implements #svn_cache__serialize_func_t for #node_revision_t
*/
svn_error_t *
-svn_fs_fs__serialize_node_revision(char **buffer,
+svn_fs_py__serialize_node_revision(char **buffer,
apr_size_t *buffer_size,
void *item,
apr_pool_t *pool);
@@ -143,7 +143,7 @@ svn_fs_fs__serialize_node_revision(char
* Implements #svn_cache__deserialize_func_t for #node_revision_t
*/
svn_error_t *
-svn_fs_fs__deserialize_node_revision(void **item,
+svn_fs_py__deserialize_node_revision(void **item,
char *buffer,
apr_size_t buffer_size,
apr_pool_t *pool);
@@ -152,7 +152,7 @@ svn_fs_fs__deserialize_node_revision(voi
* Implements #svn_cache__serialize_func_t for a directory contents hash
*/
svn_error_t *
-svn_fs_fs__serialize_dir_entries(char **data,
+svn_fs_py__serialize_dir_entries(char **data,
apr_size_t *data_len,
void *in,
apr_pool_t *pool);
@@ -161,7 +161,7 @@ svn_fs_fs__serialize_dir_entries(char **
* Implements #svn_cache__deserialize_func_t for a directory contents hash
*/
svn_error_t *
-svn_fs_fs__deserialize_dir_entries(void **out,
+svn_fs_py__deserialize_dir_entries(void **out,
char *data,
apr_size_t data_len,
apr_pool_t *pool);
@@ -171,7 +171,7 @@ svn_fs_fs__deserialize_dir_entries(void
* to the element indexed by (apr_int64_t) @a *baton within the
* serialized manifest array @a data and @a data_len. */
svn_error_t *
-svn_fs_fs__get_sharded_offset(void **out,
+svn_fs_py__get_sharded_offset(void **out,
const char *data,
apr_size_t data_len,
void *baton,
@@ -183,7 +183,7 @@ svn_fs_fs__get_sharded_offset(void **out
* identified by its name (const char @a *baton).
*/
svn_error_t *
-svn_fs_fs__extract_dir_entry(void **out,
+svn_fs_py__extract_dir_entry(void **out,
const char *data,
apr_size_t data_len,
void *baton,
@@ -210,7 +210,7 @@ typedef struct replace_baton_t
* identified by its name in the #replace_baton_t in @a baton.
*/
svn_error_t *
-svn_fs_fs__replace_dir_entry(char **data,
+svn_fs_py__replace_dir_entry(char **data,
apr_size_t *data_len,
void *baton,
apr_pool_t *pool);