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 [11/11] - in
/subversion/branches/fsfs-format7/subversion: libsvn_fs_x/ tests/libsvn_fs_x/
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/tree.h
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/tree.h?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/tree.h (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/tree.h Sun Jun 30 17:01:16 2013
@@ -33,77 +33,77 @@ extern "C" {
/* In POOL, create an instance of a DAG node 1st level cache.
The POOL will be cleared at regular intervals. */
-fs_fs_dag_cache_t*
-svn_fs_fs__create_dag_cache(apr_pool_t *pool);
+fs_x_dag_cache_t*
+svn_fs_x__create_dag_cache(apr_pool_t *pool);
/* Set *ROOT_P to the root directory of revision REV in filesystem FS.
Allocate the structure in POOL. */
-svn_error_t *svn_fs_fs__revision_root(svn_fs_root_t **root_p, svn_fs_t *fs,
- svn_revnum_t rev, apr_pool_t *pool);
+svn_error_t *svn_fs_x__revision_root(svn_fs_root_t **root_p, svn_fs_t *fs,
+ svn_revnum_t rev, apr_pool_t *pool);
/* Does nothing, but included for Subversion 1.0.x compatibility. */
-svn_error_t *svn_fs_fs__deltify(svn_fs_t *fs, svn_revnum_t rev,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__deltify(svn_fs_t *fs, svn_revnum_t rev,
+ apr_pool_t *pool);
/* Commit the transaction TXN as a new revision. Return the new
revision in *NEW_REV. If the transaction conflicts with other
changes return SVN_ERR_FS_CONFLICT and set *CONFLICT_P to a string
that details the cause of the conflict. Perform temporary
allocations in POOL. */
-svn_error_t *svn_fs_fs__commit_txn(const char **conflict_p,
- svn_revnum_t *new_rev, svn_fs_txn_t *txn,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__commit_txn(const char **conflict_p,
+ svn_revnum_t *new_rev, svn_fs_txn_t *txn,
+ apr_pool_t *pool);
/* Set ROOT_P to the root directory of transaction TXN. Allocate the
structure in POOL. */
-svn_error_t *svn_fs_fs__txn_root(svn_fs_root_t **root_p, svn_fs_txn_t *txn,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__txn_root(svn_fs_root_t **root_p, svn_fs_txn_t *txn,
+ apr_pool_t *pool);
/* Set KIND_P to the node kind of the node at PATH in ROOT.
Allocate the structure in POOL. */
svn_error_t *
-svn_fs_fs__check_path(svn_node_kind_t *kind_p,
- svn_fs_root_t *root,
- const char *path,
- apr_pool_t *pool);
+svn_fs_x__check_path(svn_node_kind_t *kind_p,
+ svn_fs_root_t *root,
+ const char *path,
+ apr_pool_t *pool);
/* Implement root_vtable_t.node_id(). */
svn_error_t *
-svn_fs_fs__node_id(const svn_fs_id_t **id_p,
- svn_fs_root_t *root,
- const char *path,
- apr_pool_t *pool);
+svn_fs_x__node_id(const svn_fs_id_t **id_p,
+ svn_fs_root_t *root,
+ const char *path,
+ apr_pool_t *pool);
/* Set *REVISION to the revision in which PATH under ROOT was created.
Use POOL for any temporary allocations. If PATH is in an
uncommitted transaction, *REVISION will be set to
SVN_INVALID_REVNUM. */
svn_error_t *
-svn_fs_fs__node_created_rev(svn_revnum_t *revision,
- svn_fs_root_t *root,
- const char *path,
- apr_pool_t *pool);
+svn_fs_x__node_created_rev(svn_revnum_t *revision,
+ svn_fs_root_t *root,
+ const char *path,
+ apr_pool_t *pool);
/* Verify metadata for ROOT.
### Currently only implemented for revision roots. */
svn_error_t *
-svn_fs_fs__verify_root(svn_fs_root_t *root,
- apr_pool_t *pool);
+svn_fs_x__verify_root(svn_fs_root_t *root,
+ apr_pool_t *pool);
svn_error_t *
-svn_fs_fs__info_format(int *fs_format,
- svn_version_t **supports_version,
- svn_fs_t *fs,
- apr_pool_t *result_pool,
- apr_pool_t *scratch_pool);
+svn_fs_x__info_format(int *fs_format,
+ svn_version_t **supports_version,
+ svn_fs_t *fs,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool);
svn_error_t *
-svn_fs_fs__info_config_files(apr_array_header_t **files,
- svn_fs_t *fs,
- apr_pool_t *result_pool,
- apr_pool_t *scratch_pool);
+svn_fs_x__info_config_files(apr_array_header_t **files,
+ svn_fs_t *fs,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool);
#ifdef __cplusplus
}
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.c (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.c Sun Jun 30 17:01:16 2013
@@ -53,18 +53,18 @@ are likely some errors because of that.
/* Return TRUE is REV is packed in FS, FALSE otherwise. */
svn_boolean_t
-is_packed_rev(svn_fs_t *fs, svn_revnum_t rev)
+svn_fs_x__is_packed_rev(svn_fs_t *fs, svn_revnum_t rev)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
return (rev < ffd->min_unpacked_rev);
}
/* Return TRUE is REV is packed in FS, FALSE otherwise. */
svn_boolean_t
-is_packed_revprop(svn_fs_t *fs, svn_revnum_t rev)
+svn_fs_x__is_packed_revprop(svn_fs_t *fs, svn_revnum_t rev)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
/* rev 0 will not be packed */
return (rev < ffd->min_unpacked_rev)
@@ -73,9 +73,9 @@ is_packed_revprop(svn_fs_t *fs, svn_revn
}
svn_revnum_t
-packed_base_rev(svn_fs_t *fs, svn_revnum_t rev)
+svn_fs_x__packed_base_rev(svn_fs_t *fs, svn_revnum_t rev)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
return rev < ffd->min_unpacked_rev
? rev - (rev % ffd->max_files_per_dir)
@@ -83,63 +83,63 @@ packed_base_rev(svn_fs_t *fs, svn_revnum
}
svn_revnum_t
-pack_size(svn_fs_t *fs, svn_revnum_t rev)
+svn_fs_x__pack_size(svn_fs_t *fs, svn_revnum_t rev)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
return rev < ffd->min_unpacked_rev ? ffd->max_files_per_dir : 1;
}
const char *
-path_format(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_format(svn_fs_t *fs, apr_pool_t *pool)
{
return svn_dirent_join(fs->path, PATH_FORMAT, pool);
}
const char *
-path_uuid(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_uuid(svn_fs_t *fs, apr_pool_t *pool)
{
return svn_dirent_join(fs->path, PATH_UUID, pool);
}
const char *
-svn_fs_fs__path_current(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_current(svn_fs_t *fs, apr_pool_t *pool)
{
return svn_dirent_join(fs->path, PATH_CURRENT, pool);
}
const char *
-path_txn_current(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_txn_current(svn_fs_t *fs, apr_pool_t *pool)
{
return svn_dirent_join(fs->path, PATH_TXN_CURRENT, pool);
}
const char *
-path_txn_current_lock(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_txn_current_lock(svn_fs_t *fs, apr_pool_t *pool)
{
return svn_dirent_join(fs->path, PATH_TXN_CURRENT_LOCK, pool);
}
const char *
-path_lock(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_lock(svn_fs_t *fs, apr_pool_t *pool)
{
return svn_dirent_join(fs->path, PATH_LOCK_FILE, pool);
}
const char *
-path_revprop_generation(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_revprop_generation(svn_fs_t *fs, apr_pool_t *pool)
{
return svn_dirent_join(fs->path, PATH_REVPROP_GENERATION, pool);
}
const char *
-path_rev_packed(svn_fs_t *fs, svn_revnum_t rev, const char *kind,
- apr_pool_t *pool)
+svn_fs_x__path_rev_packed(svn_fs_t *fs, svn_revnum_t rev, const char *kind,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
assert(ffd->max_files_per_dir);
- assert(is_packed_rev(fs, rev));
+ assert(svn_fs_x__is_packed_rev(fs, rev));
return svn_dirent_join_many(pool, fs->path, PATH_REVS_DIR,
apr_psprintf(pool,
@@ -149,9 +149,9 @@ path_rev_packed(svn_fs_t *fs, svn_revnum
}
const char *
-path_rev_shard(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+svn_fs_x__path_rev_shard(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
assert(ffd->max_files_per_dir);
return svn_dirent_join_many(pool, fs->path, PATH_REVS_DIR,
@@ -161,15 +161,15 @@ path_rev_shard(svn_fs_t *fs, svn_revnum_
}
const char *
-path_rev(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+svn_fs_x__path_rev(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
- assert(! is_packed_rev(fs, rev));
+ assert(! svn_fs_x__is_packed_rev(fs, rev));
if (ffd->max_files_per_dir)
{
- return svn_dirent_join(path_rev_shard(fs, rev, pool),
+ return svn_dirent_join(svn_fs_x__path_rev_shard(fs, rev, pool),
apr_psprintf(pool, "%ld", rev),
pool);
}
@@ -179,40 +179,42 @@ path_rev(svn_fs_t *fs, svn_revnum_t rev,
}
const char *
-path_l2p_index(svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool)
+svn_fs_x__path_l2p_index(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool)
{
return apr_psprintf(pool, "%s" PATH_EXT_L2P_INDEX,
- svn_fs_fs__path_rev_absolute(fs, rev, pool));
+ svn_fs_x__path_rev_absolute(fs, rev, pool));
}
const char *
-path_p2l_index(svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool)
+svn_fs_x__path_p2l_index(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool)
{
return apr_psprintf(pool, "%s" PATH_EXT_P2L_INDEX,
- svn_fs_fs__path_rev_absolute(fs, rev, pool));
+ svn_fs_x__path_rev_absolute(fs, rev, pool));
}
const char *
-svn_fs_fs__path_rev_absolute(svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool)
+svn_fs_x__path_rev_absolute(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
return ( ffd->format < SVN_FS_FS__MIN_PACKED_FORMAT
- || ! is_packed_rev(fs, rev))
- ? path_rev(fs, rev, pool)
- : path_rev_packed(fs, rev, PATH_PACKED, pool);
+ || ! svn_fs_x__is_packed_rev(fs, rev))
+ ? svn_fs_x__path_rev(fs, rev, pool)
+ : svn_fs_x__path_rev_packed(fs, rev, PATH_PACKED, pool);
}
const char *
-path_revprops_shard(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+svn_fs_x__path_revprops_shard(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
assert(ffd->max_files_per_dir);
return svn_dirent_join_many(pool, fs->path, PATH_REVPROPS_DIR,
@@ -222,9 +224,11 @@ path_revprops_shard(svn_fs_t *fs, svn_re
}
const char *
-path_revprops_pack_shard(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+svn_fs_x__path_revprops_pack_shard(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
assert(ffd->max_files_per_dir);
return svn_dirent_join_many(pool, fs->path, PATH_REVPROPS_DIR,
@@ -234,13 +238,13 @@ path_revprops_pack_shard(svn_fs_t *fs, s
}
const char *
-path_revprops(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
+svn_fs_x__path_revprops(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
if (ffd->max_files_per_dir)
{
- return svn_dirent_join(path_revprops_shard(fs, rev, pool),
+ return svn_dirent_join(svn_fs_x__path_revprops_shard(fs, rev, pool),
apr_psprintf(pool, "%ld", rev),
pool);
}
@@ -253,18 +257,18 @@ path_revprops(svn_fs_t *fs, svn_revnum_t
* Allocate the result in POOL.
*/
static const char *
-combine_txn_id_string(const svn_fs_fs__id_part_t *txn_id,
+combine_txn_id_string(const svn_fs_x__id_part_t *txn_id,
const char *to_add,
apr_pool_t *pool)
{
- return apr_pstrcat(pool, svn_fs_fs__id_txn_unparse(txn_id, pool),
+ return apr_pstrcat(pool, svn_fs_x__id_txn_unparse(txn_id, pool),
to_add, (char *)NULL);
}
const char *
-path_txn_dir(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__path_txn_dir(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
SVN_ERR_ASSERT_NO_RETURN(txn_id != NULL);
return svn_dirent_join_many(pool, fs->path, PATH_TXNS_DIR,
@@ -277,98 +281,102 @@ path_txn_dir(svn_fs_t *fs,
* within FS for the given SHA1 checksum. Use POOL for allocations.
*/
const char *
-path_txn_sha1(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- const unsigned char *sha1,
- apr_pool_t *pool)
+svn_fs_x__path_txn_sha1(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ const unsigned char *sha1,
+ apr_pool_t *pool)
{
svn_checksum_t checksum;
checksum.digest = sha1;
checksum.kind = svn_checksum_sha1;
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool),
+ return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
svn_checksum_to_cstring(&checksum, pool),
pool);
}
const char *
-path_txn_changes(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__path_txn_changes(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_CHANGES, pool);
+ return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
+ PATH_CHANGES, pool);
}
const char *
-path_txn_props(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__path_txn_props(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_TXN_PROPS, pool);
+ return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
+ PATH_TXN_PROPS, pool);
}
const char*
-path_l2p_proto_index(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__path_l2p_proto_index(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool),
+ return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
PATH_INDEX PATH_EXT_L2P_INDEX, pool);
}
const char*
-path_p2l_proto_index(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__path_p2l_proto_index(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool),
+ return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
PATH_INDEX PATH_EXT_P2L_INDEX, pool);
}
const char *
-path_txn_next_ids(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__path_txn_next_ids(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_NEXT_IDS, pool);
+ return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
+ PATH_NEXT_IDS, pool);
}
const char *
-path_min_unpacked_rev(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__path_min_unpacked_rev(svn_fs_t *fs, apr_pool_t *pool)
{
return svn_dirent_join(fs->path, PATH_MIN_UNPACKED_REV, pool);
}
const char *
-path_txn_item_index(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__path_txn_item_index(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool),
+ return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
PATH_TXN_ITEM_INDEX, pool);
}
const char *
-path_txn_proto_rev(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__path_txn_proto_rev(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
if (ffd->format >= SVN_FS_FS__MIN_PROTOREVS_DIR_FORMAT)
return svn_dirent_join_many(pool, fs->path, PATH_TXN_PROTOS_DIR,
combine_txn_id_string(txn_id, PATH_EXT_REV,
pool),
NULL);
else
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_REV, pool);
+ return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
+ PATH_REV, pool);
}
const char *
-path_txn_proto_rev_lock(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool)
+svn_fs_x__path_txn_proto_rev_lock(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
if (ffd->format >= SVN_FS_FS__MIN_PROTOREVS_DIR_FORMAT)
return svn_dirent_join_many(pool, fs->path, PATH_TXN_PROTOS_DIR,
combine_txn_id_string(txn_id,
@@ -376,40 +384,45 @@ path_txn_proto_rev_lock(svn_fs_t *fs,
pool),
NULL);
else
- return svn_dirent_join(path_txn_dir(fs, txn_id, pool), PATH_REV_LOCK,
- pool);
+ return svn_dirent_join(svn_fs_x__path_txn_dir(fs, txn_id, pool),
+ PATH_REV_LOCK, pool);
}
const char *
-path_txn_node_rev(svn_fs_t *fs, const svn_fs_id_t *id, apr_pool_t *pool)
+svn_fs_x__path_txn_node_rev(svn_fs_t *fs,
+ const svn_fs_id_t *id,
+ apr_pool_t *pool)
{
- char *filename = (char *)svn_fs_fs__id_unparse(id, pool)->data;
+ char *filename = (char *)svn_fs_x__id_unparse(id, pool)->data;
*strrchr(filename, '.') = '\0';
- return svn_dirent_join(path_txn_dir(fs, svn_fs_fs__id_txn_id(id), pool),
+ return svn_dirent_join(svn_fs_x__path_txn_dir(fs, svn_fs_x__id_txn_id(id),
+ pool),
apr_psprintf(pool, PATH_PREFIX_NODE "%s",
filename),
pool);
}
const char *
-path_txn_node_props(svn_fs_t *fs, const svn_fs_id_t *id, apr_pool_t *pool)
+svn_fs_x__path_txn_node_props(svn_fs_t *fs,
+ const svn_fs_id_t *id,
+ apr_pool_t *pool)
{
- return apr_pstrcat(pool, path_txn_node_rev(fs, id, pool), PATH_EXT_PROPS,
- (char *)NULL);
+ return apr_pstrcat(pool, svn_fs_x__path_txn_node_rev(fs, id, pool),
+ PATH_EXT_PROPS, (char *)NULL);
}
const char *
-path_txn_node_children(svn_fs_t *fs, const svn_fs_id_t *id, apr_pool_t *pool)
+svn_fs_x__path_txn_node_children(svn_fs_t *fs, const svn_fs_id_t *id, apr_pool_t *pool)
{
- return apr_pstrcat(pool, path_txn_node_rev(fs, id, pool),
+ return apr_pstrcat(pool, svn_fs_x__path_txn_node_rev(fs, id, pool),
PATH_EXT_CHILDREN, (char *)NULL);
}
const char *
-path_node_origin(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *node_id,
- apr_pool_t *pool)
+svn_fs_x__path_node_origin(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *node_id,
+ apr_pool_t *pool)
{
char buffer[SVN_INT64_BUFFER_SIZE];
apr_size_t len = svn__ui64tobase36(buffer, node_id->number);
@@ -429,9 +442,9 @@ path_node_origin(svn_fs_t *fs,
Uses POOL for temporary allocation. */
svn_error_t *
-check_file_buffer_numeric(const char *buf, apr_off_t offset,
- const char *path, const char *title,
- apr_pool_t *pool)
+svn_fs_x__check_file_buffer_numeric(const char *buf, apr_off_t offset,
+ const char *path, const char *title,
+ apr_pool_t *pool)
{
const char *p;
@@ -445,16 +458,16 @@ check_file_buffer_numeric(const char *bu
}
svn_error_t *
-read_min_unpacked_rev(svn_revnum_t *min_unpacked_rev,
- svn_fs_t *fs,
- apr_pool_t *pool)
+svn_fs_x__read_min_unpacked_rev(svn_revnum_t *min_unpacked_rev,
+ svn_fs_t *fs,
+ apr_pool_t *pool)
{
char buf[80];
apr_file_t *file;
apr_size_t len;
SVN_ERR(svn_io_file_open(&file,
- path_min_unpacked_rev(fs, pool),
+ svn_fs_x__path_min_unpacked_rev(fs, pool),
APR_READ | APR_BUFFERED,
APR_OS_DEFAULT,
pool));
@@ -467,13 +480,13 @@ read_min_unpacked_rev(svn_revnum_t *min_
}
svn_error_t *
-update_min_unpacked_rev(svn_fs_t *fs, apr_pool_t *pool)
+svn_fs_x__update_min_unpacked_rev(svn_fs_t *fs, apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
SVN_ERR_ASSERT(ffd->format >= SVN_FS_FS__MIN_PACKED_FORMAT);
- return read_min_unpacked_rev(&ffd->min_unpacked_rev, fs, pool);
+ return svn_fs_x__read_min_unpacked_rev(&ffd->min_unpacked_rev, fs, pool);
}
/* Write a file FILENAME in directory FS_PATH, containing a single line
@@ -482,16 +495,16 @@ update_min_unpacked_rev(svn_fs_t *fs, ap
*
* Similar to write_current(). */
svn_error_t *
-write_revnum_file(svn_fs_t *fs,
- svn_revnum_t revnum,
- apr_pool_t *scratch_pool)
+svn_fs_x__write_revnum_file(svn_fs_t *fs,
+ svn_revnum_t revnum,
+ apr_pool_t *scratch_pool)
{
const char *final_path;
char buf[SVN_INT64_BUFFER_SIZE];
apr_size_t len = svn__i64toa(buf, revnum);
buf[len] = '\n';
- final_path = path_min_unpacked_rev(fs, scratch_pool);
+ final_path = svn_fs_x__path_min_unpacked_rev(fs, scratch_pool);
SVN_ERR(svn_io_write_atomic(final_path, buf, len + 1,
final_path /* copy_perms */, scratch_pool));
@@ -504,12 +517,13 @@ write_revnum_file(svn_fs_t *fs,
ignored and may be NULL if the FS format does not use them.)
Perform temporary allocations in POOL. */
svn_error_t *
-write_current(svn_fs_t *fs, svn_revnum_t rev, apr_uint64_t next_node_id,
- apr_uint64_t next_copy_id, apr_pool_t *pool)
+svn_fs_x__write_current(svn_fs_t *fs, svn_revnum_t rev,
+ apr_uint64_t next_node_id,
+ apr_uint64_t next_copy_id, apr_pool_t *pool)
{
char *buf;
const char *tmp_name, *name;
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
/* Now we can just write out this line. */
if (ffd->format >= SVN_FS_FS__MIN_NO_GLOBAL_IDS_FORMAT)
@@ -526,13 +540,13 @@ write_current(svn_fs_t *fs, svn_revnum_t
buf = apr_psprintf(pool, "%ld %s %s\n", rev, node_id_str, copy_id_str);
}
- name = svn_fs_fs__path_current(fs, pool);
+ name = svn_fs_x__path_current(fs, pool);
SVN_ERR(svn_io_write_unique(&tmp_name,
svn_dirent_dirname(name, pool),
buf, strlen(buf),
svn_io_file_del_none, pool));
- return move_into_place(tmp_name, name, name, pool);
+ return svn_fs_x__move_into_place(tmp_name, name, name, pool);
}
@@ -547,11 +561,11 @@ write_current(svn_fs_t *fs, svn_revnum_t
* Use POOL for allocations.
*/
svn_error_t *
-try_stringbuf_from_file(svn_stringbuf_t **content,
- svn_boolean_t *missing,
- const char *path,
- svn_boolean_t last_attempt,
- apr_pool_t *pool)
+svn_fs_x__try_stringbuf_from_file(svn_stringbuf_t **content,
+ svn_boolean_t *missing,
+ const char *path,
+ svn_boolean_t last_attempt,
+ apr_pool_t *pool)
{
svn_error_t *err = svn_stringbuf_from_file2(content, path, pool);
if (missing)
@@ -589,7 +603,9 @@ try_stringbuf_from_file(svn_stringbuf_t
/* Fetch the current offset of FILE into *OFFSET_P. */
svn_error_t *
-get_file_offset(apr_off_t *offset_p, apr_file_t *file, apr_pool_t *pool)
+svn_fs_x__get_file_offset(apr_off_t *offset_p,
+ apr_file_t *file,
+ apr_pool_t *pool)
{
apr_off_t offset;
@@ -605,13 +621,15 @@ get_file_offset(apr_off_t *offset_p, apr
/* Read the 'current' file FNAME and store the contents in *BUF.
Allocations are performed in POOL. */
svn_error_t *
-read_content(svn_stringbuf_t **content, const char *fname, apr_pool_t *pool)
+svn_fs_x__read_content(svn_stringbuf_t **content,
+ const char *fname,
+ apr_pool_t *pool)
{
int i;
*content = NULL;
for (i = 0; !*content && (i < RECOVERABLE_RETRY_COUNT); ++i)
- SVN_ERR(try_stringbuf_from_file(content, NULL,
+ SVN_ERR(svn_fs_x__try_stringbuf_from_file(content, NULL,
fname, i + 1 < RECOVERABLE_RETRY_COUNT,
pool));
@@ -630,10 +648,10 @@ read_content(svn_stringbuf_t **content,
* SCRATCH_POOL is used for temporary allocations.
*/
svn_error_t *
-read_number_from_stream(apr_int64_t *result,
- svn_boolean_t *hit_eof,
- svn_stream_t *stream,
- apr_pool_t *scratch_pool)
+svn_fs_x__read_number_from_stream(apr_int64_t *result,
+ svn_boolean_t *hit_eof,
+ svn_stream_t *stream,
+ apr_pool_t *scratch_pool)
{
svn_stringbuf_t *sb;
svn_boolean_t eof;
@@ -667,10 +685,10 @@ read_number_from_stream(apr_int64_t *res
This function almost duplicates svn_io_file_move(), but it tries to
guarantee a flush. */
svn_error_t *
-move_into_place(const char *old_filename,
- const char *new_filename,
- const char *perms_reference,
- apr_pool_t *pool)
+svn_fs_x__move_into_place(const char *old_filename,
+ const char *new_filename,
+ const char *perms_reference,
+ apr_pool_t *pool)
{
svn_error_t *err;
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.h
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.h?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.h (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/util.h Sun Jun 30 17:01:16 2013
@@ -70,166 +70,166 @@
/* Return TRUE is REV is packed in FS, FALSE otherwise. */
svn_boolean_t
-is_packed_rev(svn_fs_t *fs,
- svn_revnum_t rev);
+svn_fs_x__is_packed_rev(svn_fs_t *fs,
+ svn_revnum_t rev);
/* Return TRUE is REV is packed in FS, FALSE otherwise. */
svn_boolean_t
-is_packed_revprop(svn_fs_t *fs,
- svn_revnum_t rev);
+svn_fs_x__is_packed_revprop(svn_fs_t *fs,
+ svn_revnum_t rev);
/* Return the revision number of the pack / rev file in FS containing REV. */
svn_revnum_t
-packed_base_rev(svn_fs_t *fs, svn_revnum_t rev);
+svn_fs_x__packed_base_rev(svn_fs_t *fs, svn_revnum_t rev);
/* Return the number of revisions in the pack / rev file in FS that contains
* revision REV. */
svn_revnum_t
-pack_size(svn_fs_t *fs, svn_revnum_t rev);
+svn_fs_x__pack_size(svn_fs_t *fs, svn_revnum_t rev);
const char *
-path_format(svn_fs_t *fs,
- apr_pool_t *pool);
+svn_fs_x__path_format(svn_fs_t *fs,
+ apr_pool_t *pool);
const char *
-path_uuid(svn_fs_t *fs,
- apr_pool_t *pool);
+svn_fs_x__path_uuid(svn_fs_t *fs,
+ apr_pool_t *pool);
const char *
-path_txn_current(svn_fs_t *fs,
- apr_pool_t *pool);
+svn_fs_x__path_txn_current(svn_fs_t *fs,
+ apr_pool_t *pool);
const char *
-path_txn_current_lock(svn_fs_t *fs,
- apr_pool_t *pool);
+svn_fs_x__path_txn_current_lock(svn_fs_t *fs,
+ apr_pool_t *pool);
const char *
-path_lock(svn_fs_t *fs,
- apr_pool_t *pool);
+svn_fs_x__path_lock(svn_fs_t *fs,
+ apr_pool_t *pool);
const char *
-path_revprop_generation(svn_fs_t *fs,
- apr_pool_t *pool);
+svn_fs_x__path_revprop_generation(svn_fs_t *fs,
+ apr_pool_t *pool);
const char *
-path_rev_packed(svn_fs_t *fs,
- svn_revnum_t rev,
- const char *kind,
- apr_pool_t *pool);
+svn_fs_x__path_rev_packed(svn_fs_t *fs,
+ svn_revnum_t rev,
+ const char *kind,
+ apr_pool_t *pool);
const char *
-path_rev_shard(svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool);
+svn_fs_x__path_rev_shard(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool);
const char *
-path_rev(svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool);
+svn_fs_x__path_rev(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool);
const char *
-path_l2p_index(svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool);
+svn_fs_x__path_l2p_index(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool);
const char *
-path_p2l_index(svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool);
+svn_fs_x__path_p2l_index(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool);
const char *
-path_revprops_shard(svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool);
+svn_fs_x__path_revprops_shard(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool);
const char *
-path_revprops_pack_shard(svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool);
+svn_fs_x__path_revprops_pack_shard(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool);
const char *
-path_revprops(svn_fs_t *fs,
- svn_revnum_t rev,
- apr_pool_t *pool);
+svn_fs_x__path_revprops(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool);
const char *
-path_txn_dir(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool);
+svn_fs_x__path_txn_dir(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool);
/* Return the name of the sha1->rep mapping file in transaction TXN_ID
* within FS for the given SHA1 checksum. Use POOL for allocations.
*/
const char *
-path_txn_sha1(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- const unsigned char *sha1,
- apr_pool_t *pool);
+svn_fs_x__path_txn_sha1(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ const unsigned char *sha1,
+ apr_pool_t *pool);
const char *
-path_txn_changes(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool);
+svn_fs_x__path_txn_changes(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool);
const char*
-path_l2p_proto_index(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool);
+svn_fs_x__path_l2p_proto_index(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool);
const char*
-path_p2l_proto_index(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool);
+svn_fs_x__path_p2l_proto_index(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool);
const char *
-path_txn_props(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool);
+svn_fs_x__path_txn_props(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool);
const char *
-path_txn_next_ids(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool);
+svn_fs_x__path_txn_next_ids(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool);
const char *
-path_min_unpacked_rev(svn_fs_t *fs,
- apr_pool_t *pool);
+svn_fs_x__path_min_unpacked_rev(svn_fs_t *fs,
+ apr_pool_t *pool);
const char *
-path_txn_item_index(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool);
+svn_fs_x__path_txn_item_index(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool);
const char *
-path_txn_proto_rev(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool);
+svn_fs_x__path_txn_proto_rev(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool);
const char *
-path_txn_proto_rev_lock(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *txn_id,
- apr_pool_t *pool);
+svn_fs_x__path_txn_proto_rev_lock(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *txn_id,
+ apr_pool_t *pool);
const char *
-path_txn_node_rev(svn_fs_t *fs,
- const svn_fs_id_t *id,
- apr_pool_t *pool);
+svn_fs_x__path_txn_node_rev(svn_fs_t *fs,
+ const svn_fs_id_t *id,
+ apr_pool_t *pool);
const char *
-path_txn_node_props(svn_fs_t *fs,
- const svn_fs_id_t *id,
- apr_pool_t *pool);
+svn_fs_x__path_txn_node_props(svn_fs_t *fs,
+ const svn_fs_id_t *id,
+ apr_pool_t *pool);
const char *
-path_txn_node_children(svn_fs_t *fs,
- const svn_fs_id_t *id,
- apr_pool_t *pool);
+svn_fs_x__path_txn_node_children(svn_fs_t *fs,
+ const svn_fs_id_t *id,
+ apr_pool_t *pool);
const char *
-path_node_origin(svn_fs_t *fs,
- const svn_fs_fs__id_part_t *node_id,
- apr_pool_t *pool);
+svn_fs_x__path_node_origin(svn_fs_t *fs,
+ const svn_fs_x__id_part_t *node_id,
+ apr_pool_t *pool);
/* Check that BUF, a nul-terminated buffer of text from file PATH,
contains only digits at OFFSET and beyond, raising an error if not.
@@ -238,20 +238,20 @@ path_node_origin(svn_fs_t *fs,
Uses POOL for temporary allocation. */
svn_error_t *
-check_file_buffer_numeric(const char *buf,
- apr_off_t offset,
- const char *path,
- const char *title,
- apr_pool_t *pool);
+svn_fs_x__check_file_buffer_numeric(const char *buf,
+ apr_off_t offset,
+ const char *path,
+ const char *title,
+ apr_pool_t *pool);
svn_error_t *
-read_min_unpacked_rev(svn_revnum_t *min_unpacked_rev,
- svn_fs_t *fs,
- apr_pool_t *pool);
+svn_fs_x__read_min_unpacked_rev(svn_revnum_t *min_unpacked_rev,
+ svn_fs_t *fs,
+ apr_pool_t *pool);
svn_error_t *
-update_min_unpacked_rev(svn_fs_t *fs,
- apr_pool_t *pool);
+svn_fs_x__update_min_unpacked_rev(svn_fs_t *fs,
+ apr_pool_t *pool);
/* Write a file FILENAME in directory FS_PATH, containing a single line
* with the number REVNUM in ASCII decimal. Move the file into place
@@ -259,20 +259,20 @@ update_min_unpacked_rev(svn_fs_t *fs,
*
* Similar to write_current(). */
svn_error_t *
-write_revnum_file(svn_fs_t *fs,
- svn_revnum_t revnum,
- apr_pool_t *scratch_pool);
+svn_fs_x__write_revnum_file(svn_fs_t *fs,
+ svn_revnum_t revnum,
+ apr_pool_t *scratch_pool);
/* Atomically update the 'current' file to hold the specifed REV,
NEXT_NODE_ID, and NEXT_COPY_ID. (The two next-ID parameters are
ignored and may be 0 if the FS format does not use them.)
Perform temporary allocations in POOL. */
svn_error_t *
-write_current(svn_fs_t *fs,
- svn_revnum_t rev,
- apr_uint64_t next_node_id,
- apr_uint64_t next_copy_id,
- apr_pool_t *pool);
+svn_fs_x__write_current(svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_uint64_t next_node_id,
+ apr_uint64_t next_copy_id,
+ apr_pool_t *pool);
/* Read the file at PATH and return its content in *CONTENT. *CONTENT will
* not be modified unless the whole file was read successfully.
@@ -284,24 +284,24 @@ write_current(svn_fs_t *fs,
* Use POOL for allocations.
*/
svn_error_t *
-try_stringbuf_from_file(svn_stringbuf_t **content,
- svn_boolean_t *missing,
- const char *path,
- svn_boolean_t last_attempt,
- apr_pool_t *pool);
+svn_fs_x__try_stringbuf_from_file(svn_stringbuf_t **content,
+ svn_boolean_t *missing,
+ const char *path,
+ svn_boolean_t last_attempt,
+ apr_pool_t *pool);
/* Fetch the current offset of FILE into *OFFSET_P. */
svn_error_t *
-get_file_offset(apr_off_t *offset_p,
- apr_file_t *file,
- apr_pool_t *pool);
+svn_fs_x__get_file_offset(apr_off_t *offset_p,
+ apr_file_t *file,
+ apr_pool_t *pool);
/* Read the file FNAME and store the contents in *BUF.
Allocations are performed in POOL. */
svn_error_t *
-read_content(svn_stringbuf_t **content,
- const char *fname,
- apr_pool_t *pool);
+svn_fs_x__read_content(svn_stringbuf_t **content,
+ const char *fname,
+ apr_pool_t *pool);
/* Reads a line from STREAM and converts it to a 64 bit integer to be
* returned in *RESULT. If we encounter eof, set *HIT_EOF and leave
@@ -310,10 +310,10 @@ read_content(svn_stringbuf_t **content,
* SCRATCH_POOL is used for temporary allocations.
*/
svn_error_t *
-read_number_from_stream(apr_int64_t *result,
- svn_boolean_t *hit_eof,
- svn_stream_t *stream,
- apr_pool_t *scratch_pool);
+svn_fs_x__read_number_from_stream(apr_int64_t *result,
+ svn_boolean_t *hit_eof,
+ svn_stream_t *stream,
+ apr_pool_t *scratch_pool);
/* Move a file into place from OLD_FILENAME in the transactions
directory to its final location NEW_FILENAME in the repository. On
@@ -323,9 +323,9 @@ read_number_from_stream(apr_int64_t *res
This function almost duplicates svn_io_file_move(), but it tries to
guarantee a flush. */
svn_error_t *
-move_into_place(const char *old_filename,
- const char *new_filename,
- const char *perms_reference,
- apr_pool_t *pool);
+svn_fs_x__move_into_place(const char *old_filename,
+ const char *new_filename,
+ const char *perms_reference,
+ apr_pool_t *pool);
#endif
\ No newline at end of file
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.c (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.c Sun Jun 30 17:01:16 2013
@@ -56,15 +56,15 @@ typedef struct verify_walker_baton_t
/* remember the last revision for which we called notify_func */
svn_revnum_t last_notified_revision;
- /* cached hint for successive calls to svn_fs_fs__check_rep() */
+ /* cached hint for successive calls to svn_fs_x__check_rep() */
void *hint;
/* pool to use for the file handles etc. */
apr_pool_t *pool;
} verify_walker_baton_t;
-/* Used by svn_fs_fs__verify().
- Implements svn_fs_fs__walk_rep_reference().walker. */
+/* Used by svn_fs_x__verify().
+ Implements svn_fs_x__walk_rep_reference().walker. */
static svn_error_t *
verify_walker(representation_t *rep,
void *baton,
@@ -96,7 +96,7 @@ verify_walker(representation_t *rep,
/* access the repo data */
previous_hint = walker_baton->hint;
- SVN_ERR(svn_fs_fs__check_rep(rep, fs, &walker_baton->hint,
+ SVN_ERR(svn_fs_x__check_rep(rep, fs, &walker_baton->hint,
walker_baton->pool));
/* update resource usage counters */
@@ -108,7 +108,7 @@ verify_walker(representation_t *rep,
}
/* Verify the rep cache DB's consistency with our rev / pack data.
- * The function signature is similar to svn_fs_fs__verify.
+ * The function signature is similar to svn_fs_x__verify.
* The values of START and END have already been auto-selected and
* verified.
*/
@@ -125,7 +125,7 @@ verify_rep_cache(svn_fs_t *fs,
svn_boolean_t exists;
/* rep-cache verification. */
- SVN_ERR(svn_fs_fs__exists_rep_cache(&exists, fs, pool));
+ SVN_ERR(svn_fs_x__exists_rep_cache(&exists, fs, pool));
if (exists)
{
/* provide a baton to allow the reuse of open file handles between
@@ -143,10 +143,10 @@ verify_rep_cache(svn_fs_t *fs,
/* Do not attempt to walk the rep-cache database if its file does
not exist, since doing so would create it --- which may confuse
the administrator. Don't take any lock. */
- SVN_ERR(svn_fs_fs__walk_rep_reference(fs, start, end,
- verify_walker, baton,
- cancel_func, cancel_baton,
- pool));
+ SVN_ERR(svn_fs_x__walk_rep_reference(fs, start, end,
+ verify_walker, baton,
+ cancel_func, cancel_baton,
+ pool));
/* walker resource cleanup */
svn_pool_destroy(baton->pool);
@@ -173,7 +173,7 @@ compare_l2p_to_p2l_index(svn_fs_t *fs,
apr_array_header_t *max_ids;
/* determine the range of items to check for each revision */
- SVN_ERR(svn_fs_fs__l2p_get_max_ids(&max_ids, fs, start, count, pool));
+ SVN_ERR(svn_fs_x__l2p_get_max_ids(&max_ids, fs, start, count, pool));
/* check all items in all revisions if the given range */
for (i = 0; i < max_ids->nelts; ++i)
@@ -186,17 +186,17 @@ compare_l2p_to_p2l_index(svn_fs_t *fs,
{
apr_off_t offset;
apr_uint32_t sub_item;
- svn_fs_fs__id_part_t *p2l_item;
+ svn_fs_x__id_part_t *p2l_item;
/* get L2P entry. Ignore unused entries. */
- SVN_ERR(svn_fs_fs__item_offset(&offset, &sub_item, fs,
- revision, NULL, k, iterpool));
+ SVN_ERR(svn_fs_x__item_offset(&offset, &sub_item, fs,
+ revision, NULL, k, iterpool));
if (offset == -1)
continue;
/* find the corresponding P2L entry */
- SVN_ERR(svn_fs_fs__p2l_item_lookup(&p2l_item, fs, start,
- offset, sub_item, iterpool));
+ SVN_ERR(svn_fs_x__p2l_item_lookup(&p2l_item, fs, start,
+ offset, sub_item, iterpool));
if (p2l_item == NULL)
return svn_error_createf(SVN_ERR_FS_ITEM_INDEX_INCONSISTENT,
@@ -250,19 +250,19 @@ compare_p2l_to_l2p_index(svn_fs_t *fs,
apr_off_t offset = 0;
/* get the size of the rev / pack file as covered by the P2L index */
- SVN_ERR(svn_fs_fs__p2l_get_max_offset(&max_offset, fs, start, pool));
+ SVN_ERR(svn_fs_x__p2l_get_max_offset(&max_offset, fs, start, pool));
/* for all offsets in the file, get the P2L index entries and check
them against the L2P index */
for (offset = 0; offset < max_offset; )
{
apr_array_header_t *entries;
- svn_fs_fs__p2l_entry_t *last_entry;
+ svn_fs_x__p2l_entry_t *last_entry;
int i;
/* get all entries for the current block */
- SVN_ERR(svn_fs_fs__p2l_index_lookup(&entries, fs, start, offset,
- iterpool));
+ SVN_ERR(svn_fs_x__p2l_index_lookup(&entries, fs, start, offset,
+ iterpool));
if (entries->nelts == 0)
return svn_error_createf(SVN_ERR_FS_ITEM_INDEX_CORRUPTION,
NULL,
@@ -272,25 +272,25 @@ compare_p2l_to_l2p_index(svn_fs_t *fs,
/* process all entries (and later continue with the next block) */
last_entry
- = &APR_ARRAY_IDX(entries, entries->nelts-1, svn_fs_fs__p2l_entry_t);
+ = &APR_ARRAY_IDX(entries, entries->nelts-1, svn_fs_x__p2l_entry_t);
offset = last_entry->offset + last_entry->size;
for (i = 0; i < entries->nelts; ++i)
{
apr_uint32_t k;
- svn_fs_fs__p2l_entry_t *entry
- = &APR_ARRAY_IDX(entries, i, svn_fs_fs__p2l_entry_t);
+ svn_fs_x__p2l_entry_t *entry
+ = &APR_ARRAY_IDX(entries, i, svn_fs_x__p2l_entry_t);
/* check all sub-items for consist entries in the L2P index */
for (k = 0; k < entry->item_count; ++k)
{
apr_off_t l2p_offset;
apr_uint32_t sub_item;
- svn_fs_fs__id_part_t *p2l_item = &entry->items[k];
+ svn_fs_x__id_part_t *p2l_item = &entry->items[k];
- SVN_ERR(svn_fs_fs__item_offset(&l2p_offset, &sub_item, fs,
- p2l_item->revision, NULL,
- p2l_item->number, iterpool));
+ SVN_ERR(svn_fs_x__item_offset(&l2p_offset, &sub_item, fs,
+ p2l_item->revision, NULL,
+ p2l_item->number, iterpool));
if (sub_item != k || l2p_offset != entry->offset)
return svn_error_createf(SVN_ERR_FS_ITEM_INDEX_INCONSISTENT,
@@ -320,7 +320,7 @@ compare_p2l_to_l2p_index(svn_fs_t *fs,
/* Verify that the log-to-phys indexes and phys-to-log indexes are
* consistent with each other. The function signature is similar to
- * svn_fs_fs__verify.
+ * svn_fs_x__verify.
*
* The values of START and END have already been auto-selected and
* verified. You may call this for format7 or higher repos.
@@ -335,14 +335,14 @@ verify_index_consistency(svn_fs_t *fs,
void *cancel_baton,
apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
svn_revnum_t revision, pack_start, pack_end;
apr_pool_t *iterpool = svn_pool_create(pool);
for (revision = start; revision <= end; revision = pack_end)
{
- pack_start = packed_base_rev(fs, revision);
- pack_end = pack_start + pack_size(fs, revision);
+ pack_start = svn_fs_x__packed_base_rev(fs, revision);
+ pack_end = pack_start + svn_fs_x__pack_size(fs, revision);
if (notify_func && (pack_start % ffd->max_files_per_dir == 0))
notify_func(pack_start, notify_baton, iterpool);
@@ -362,16 +362,16 @@ verify_index_consistency(svn_fs_t *fs,
}
svn_error_t *
-svn_fs_fs__verify(svn_fs_t *fs,
- svn_revnum_t start,
- svn_revnum_t end,
- svn_fs_progress_notify_func_t notify_func,
- void *notify_baton,
- svn_cancel_func_t cancel_func,
- void *cancel_baton,
- apr_pool_t *pool)
+svn_fs_x__verify(svn_fs_t *fs,
+ svn_revnum_t start,
+ svn_revnum_t end,
+ svn_fs_progress_notify_func_t notify_func,
+ void *notify_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
{
- fs_fs_data_t *ffd = fs->fsap_data;
+ fs_x_data_t *ffd = fs->fsap_data;
svn_revnum_t youngest = ffd->youngest_rev_cache; /* cache is current */
/* Input validation. */
@@ -379,8 +379,8 @@ svn_fs_fs__verify(svn_fs_t *fs,
start = 0;
if (! SVN_IS_VALID_REVNUM(end))
end = youngest;
- SVN_ERR(svn_fs_fs__ensure_revision_exists(start, fs, pool));
- SVN_ERR(svn_fs_fs__ensure_revision_exists(end, fs, pool));
+ SVN_ERR(svn_fs_x__ensure_revision_exists(start, fs, pool));
+ SVN_ERR(svn_fs_x__ensure_revision_exists(end, fs, pool));
/* log/phys index consistency. We need to check them first to make
sure we can access the rev / pack files in format7. */
Modified: subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.h
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.h?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.h (original)
+++ subversion/branches/fsfs-format7/subversion/libsvn_fs_x/verify.h Sun Jun 30 17:01:16 2013
@@ -30,13 +30,13 @@
* NOTIFY_FUNC callback using NOTIFY_BATON. The optional CANCEL_FUNC
* will periodically be called with CANCEL_BATON to allow for preemption.
* Use POOL for temporary allocations. */
-svn_error_t *svn_fs_fs__verify(svn_fs_t *fs,
- svn_revnum_t start,
- svn_revnum_t end,
- svn_fs_progress_notify_func_t notify_func,
- void *notify_baton,
- svn_cancel_func_t cancel_func,
- void *cancel_baton,
- apr_pool_t *pool);
+svn_error_t *svn_fs_x__verify(svn_fs_t *fs,
+ svn_revnum_t start,
+ svn_revnum_t end,
+ svn_fs_progress_notify_func_t notify_func,
+ void *notify_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool);
#endif
Modified: subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/fs-x-pack-test.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/fs-x-pack-test.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/fs-x-pack-test.c (original)
+++ subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/fs-x-pack-test.c Sun Jun 30 17:01:16 2013
@@ -272,7 +272,7 @@ huge_log(svn_revnum_t rev, apr_pool_t *p
/*** Tests ***/
/* ------------------------------------------------------------------------ */
-#define REPO_NAME "test-repo-fsfs-pack"
+#define REPO_NAME "test-repo-fsx-pack"
#define SHARD_SIZE 7
#define MAX_REV 53
static svn_error_t *
@@ -287,7 +287,7 @@ pack_filesystem(const svn_test_opts_t *o
apr_size_t len;
/* Bail (with success) on known-untestable scenarios */
- if ((strcmp(opts->fs_type, "fsfs") != 0)
+ if ((strcmp(opts->fs_type, "fsx") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 6)))
return SVN_NO_ERROR;
@@ -379,7 +379,7 @@ pack_filesystem(const svn_test_opts_t *o
#undef MAX_REV
/* ------------------------------------------------------------------------ */
-#define REPO_NAME "test-repo-fsfs-pack-even"
+#define REPO_NAME "test-repo-fsx-pack-even"
#define SHARD_SIZE 4
#define MAX_REV 11
static svn_error_t *
@@ -390,7 +390,7 @@ pack_even_filesystem(const svn_test_opts
const char *path;
/* Bail (with success) on known-untestable scenarios */
- if ((strcmp(opts->fs_type, "fsfs") != 0)
+ if ((strcmp(opts->fs_type, "fsx") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 6)))
return SVN_NO_ERROR;
@@ -423,7 +423,7 @@ read_packed_fs(const svn_test_opts_t *op
svn_revnum_t i;
/* Bail (with success) on known-untestable scenarios */
- if ((strcmp(opts->fs_type, "fsfs") != 0)
+ if ((strcmp(opts->fs_type, "fsx") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 6)))
return SVN_NO_ERROR;
@@ -470,7 +470,7 @@ commit_packed_fs(const svn_test_opts_t *
svn_revnum_t after_rev;
/* Bail (with success) on known-untestable scenarios */
- if ((strcmp(opts->fs_type, "fsfs") != 0)
+ if ((strcmp(opts->fs_type, "fsx") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 6)))
return SVN_NO_ERROR;
@@ -505,7 +505,7 @@ get_set_revprop_packed_fs(const svn_test
svn_string_t *prop_value;
/* Bail (with success) on known-untestable scenarios */
- if ((strcmp(opts->fs_type, "fsfs") != 0)
+ if ((strcmp(opts->fs_type, "fsx") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 7)))
return SVN_NO_ERROR;
@@ -562,7 +562,7 @@ get_set_large_revprop_packed_fs(const sv
svn_revnum_t rev;
/* Bail (with success) on known-untestable scenarios */
- if ((strcmp(opts->fs_type, "fsfs") != 0)
+ if ((strcmp(opts->fs_type, "fsx") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 7)))
return SVN_NO_ERROR;
@@ -635,7 +635,7 @@ get_set_huge_revprop_packed_fs(const svn
svn_revnum_t rev;
/* Bail (with success) on known-untestable scenarios */
- if ((strcmp(opts->fs_type, "fsfs") != 0)
+ if ((strcmp(opts->fs_type, "fsx") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 7)))
return SVN_NO_ERROR;
@@ -708,7 +708,7 @@ recover_fully_packed(const svn_test_opts
svn_error_t *err;
/* Bail (with success) on known-untestable scenarios */
- if ((strcmp(opts->fs_type, "fsfs") != 0)
+ if ((strcmp(opts->fs_type, "fsx") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 7)))
return SVN_NO_ERROR;
@@ -771,7 +771,7 @@ file_hint_at_shard_boundary(const svn_te
svn_error_t *err = SVN_NO_ERROR;
/* Bail (with success) on known-untestable scenarios */
- if ((strcmp(opts->fs_type, "fsfs") != 0)
+ if ((strcmp(opts->fs_type, "fsx") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 8)))
return SVN_NO_ERROR;
@@ -808,7 +808,7 @@ file_hint_at_shard_boundary(const svn_te
#undef SHARD_SIZE
/* ------------------------------------------------------------------------ */
-#define REPO_NAME "test-repo-fsfs-info"
+#define REPO_NAME "test-repo-fsx-info"
#define SHARD_SIZE 3
#define MAX_REV 5
static svn_error_t *
@@ -829,7 +829,7 @@ test_info(const svn_test_opts_t *opts,
SVN_TEST_STRING_ASSERT(opts->fs_type, info->fs_type);
/* Bail (with success) on known-untestable scenarios */
- if (strcmp(opts->fs_type, "fsfs") != 0)
+ if (strcmp(opts->fs_type, "fsx") != 0)
return SVN_NO_ERROR;
fsfs_info = (const void *)info;
@@ -852,7 +852,7 @@ test_info(const svn_test_opts_t *opts,
#undef MAX_REV
/* ------------------------------------------------------------------------ */
-#define REPO_NAME "test-repo-fsfs-rev-container"
+#define REPO_NAME "test-repo-fsx-rev-container"
#define SHARD_SIZE 3
#define MAX_REV 5
static svn_error_t *
@@ -860,8 +860,8 @@ test_reps(const svn_test_opts_t *opts,
apr_pool_t *pool)
{
svn_fs_t *fs = NULL;
- svn_fs_fs__reps_builder_t *builder;
- svn_fs_fs__reps_t *container;
+ svn_fs_x__reps_builder_t *builder;
+ svn_fs_x__reps_t *container;
svn_stringbuf_t *serialized;
svn_stream_t *stream;
svn_stringbuf_t *contents = svn_stringbuf_create_ensure(10000, pool);
@@ -881,22 +881,22 @@ test_reps(const svn_test_opts_t *opts,
SVN_ERR(svn_fs_open(&fs, REPO_NAME, NULL, pool));
- builder = svn_fs_fs__reps_builder_create(fs, pool);
+ builder = svn_fs_x__reps_builder_create(fs, pool);
for (i = 10000; i > 10; --i)
{
svn_string_t string;
string.data = contents->data;
string.len = i;
- svn_fs_fs__reps_add(builder, &string);
+ svn_fs_x__reps_add(builder, &string);
}
serialized = svn_stringbuf_create_empty(pool);
stream = svn_stream_from_stringbuf(serialized, pool);
- SVN_ERR(svn_fs_fs__write_reps_container(stream, builder, pool));
+ SVN_ERR(svn_fs_x__write_reps_container(stream, builder, pool));
SVN_ERR(svn_stream_reset(stream));
- SVN_ERR(svn_fs_fs__read_reps_container(&container, stream, pool, pool));
+ SVN_ERR(svn_fs_x__read_reps_container(&container, stream, pool, pool));
SVN_ERR(svn_stream_close(stream));
return SVN_NO_ERROR;
@@ -907,7 +907,7 @@ test_reps(const svn_test_opts_t *opts,
#undef MAX_REV
/* ------------------------------------------------------------------------ */
-#define REPO_NAME "test-repo-fsfs-pack-shard-size-one"
+#define REPO_NAME "test-repo-fsx-pack-shard-size-one"
#define SHARD_SIZE 1
#define MAX_REV 4
static svn_error_t *
@@ -918,7 +918,7 @@ pack_shard_size_one(const svn_test_opts_
svn_fs_t *fs;
/* Bail (with success) on known-untestable scenarios */
- if ((strcmp(opts->fs_type, "fsfs") != 0)
+ if ((strcmp(opts->fs_type, "fsx") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 6)))
return SVN_NO_ERROR;
Modified: subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/string-table-test.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/string-table-test.c?rev=1498157&r1=1498156&r2=1498157&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/string-table-test.c (original)
+++ subversion/branches/fsfs-format7/subversion/tests/libsvn_fs_x/string-table-test.c Sun Jun 30 17:01:16 2013
@@ -61,7 +61,7 @@ generate_string(apr_uint64_t key, apr_si
{
apr_size_t idx;
apr_size_t add_len;
-
+
if (temp == 0)
{
temp = key;
@@ -88,13 +88,13 @@ store_and_load_table(string_table_t **ta
svn_stream_t *stream;
stream = svn_stream_from_stringbuf(stream_buffer, pool);
- SVN_ERR(svn_fs_fs__write_string_table(stream, *table, pool));
+ SVN_ERR(svn_fs_x__write_string_table(stream, *table, pool));
SVN_ERR(svn_stream_close(stream));
*table = NULL;
stream = svn_stream_from_stringbuf(stream_buffer, pool);
- SVN_ERR(svn_fs_fs__read_string_table(table, stream, pool, pool));
+ SVN_ERR(svn_fs_x__read_string_table(table, stream, pool, pool));
SVN_ERR(svn_stream_close(stream));
return SVN_NO_ERROR;
@@ -105,16 +105,16 @@ create_empty_table_body(svn_boolean_t do
apr_pool_t *pool)
{
string_table_builder_t *builder
- = svn_fs_fs__string_table_builder_create(pool);
+ = svn_fs_x__string_table_builder_create(pool);
string_table_t *table
- = svn_fs_fs__string_table_create(builder, pool);
+ = svn_fs_x__string_table_create(builder, pool);
- SVN_TEST_STRING_ASSERT(svn_fs_fs__string_table_get(table, 0, NULL, pool), "");
+ SVN_TEST_STRING_ASSERT(svn_fs_x__string_table_get(table, 0, NULL, pool), "");
if (do_load_store)
SVN_ERR(store_and_load_table(&table, pool));
- SVN_TEST_STRING_ASSERT(svn_fs_fs__string_table_get(table, 0, NULL, pool), "");
+ SVN_TEST_STRING_ASSERT(svn_fs_x__string_table_get(table, 0, NULL, pool), "");
return SVN_NO_ERROR;
}
@@ -129,11 +129,11 @@ short_string_table_body(svn_boolean_t do
string_table_t *table;
int i;
- builder = svn_fs_fs__string_table_builder_create(pool);
+ builder = svn_fs_x__string_table_builder_create(pool);
for (i = 0; i < STRING_COUNT; ++i)
- indexes[i] = svn_fs_fs__string_table_builder_add(builder, basic_strings[i], 0);
+ indexes[i] = svn_fs_x__string_table_builder_add(builder, basic_strings[i], 0);
- table = svn_fs_fs__string_table_create(builder, pool);
+ table = svn_fs_x__string_table_create(builder, pool);
if (do_load_store)
SVN_ERR(store_and_load_table(&table, pool));
@@ -142,15 +142,15 @@ short_string_table_body(svn_boolean_t do
{
apr_size_t len;
const char *string
- = svn_fs_fs__string_table_get(table, indexes[i], &len, pool);
+ = svn_fs_x__string_table_get(table, indexes[i], &len, pool);
SVN_TEST_STRING_ASSERT(string, basic_strings[i]);
SVN_TEST_ASSERT(len == strlen(string));
SVN_TEST_ASSERT(len == strlen(basic_strings[i]));
}
- SVN_TEST_STRING_ASSERT(svn_fs_fs__string_table_get(table, STRING_COUNT,
- NULL, pool), "");
+ SVN_TEST_STRING_ASSERT(svn_fs_x__string_table_get(table, STRING_COUNT,
+ NULL, pool), "");
return SVN_NO_ERROR;
}
@@ -168,14 +168,14 @@ large_string_table_body(svn_boolean_t do
string_table_t *table;
int i;
- builder = svn_fs_fs__string_table_builder_create(pool);
+ builder = svn_fs_x__string_table_builder_create(pool);
for (i = 0; i < COUNT; ++i)
{
strings[i] = generate_string(0x1234567876543210ull * (i + 1), 73000 + 1000 * i, pool);
- indexes[i] = svn_fs_fs__string_table_builder_add(builder, strings[i]->data, strings[i]->len);
+ indexes[i] = svn_fs_x__string_table_builder_add(builder, strings[i]->data, strings[i]->len);
}
- table = svn_fs_fs__string_table_create(builder, pool);
+ table = svn_fs_x__string_table_create(builder, pool);
if (do_load_store)
SVN_ERR(store_and_load_table(&table, pool));
@@ -183,7 +183,7 @@ large_string_table_body(svn_boolean_t do
{
apr_size_t len;
const char *string
- = svn_fs_fs__string_table_get(table, indexes[i], &len, pool);
+ = svn_fs_x__string_table_get(table, indexes[i], &len, pool);
SVN_TEST_STRING_ASSERT(string, strings[i]->data);
SVN_TEST_ASSERT(len == strlen(string));
@@ -207,14 +207,17 @@ many_strings_table_body(svn_boolean_t do
string_table_t *table;
int i;
- builder = svn_fs_fs__string_table_builder_create(pool);
+ builder = svn_fs_x__string_table_builder_create(pool);
for (i = 0; i < COUNT; ++i)
{
- strings[i] = generate_string(0x1234567876543210ull * (i + 1), (i * i) % 23000, pool);
- indexes[i] = svn_fs_fs__string_table_builder_add(builder, strings[i]->data, strings[i]->len);
+ strings[i] = generate_string(0x1234567876543210ull * (i + 1),
+ (i * i) % 23000, pool);
+ indexes[i] = svn_fs_x__string_table_builder_add(builder,
+ strings[i]->data,
+ strings[i]->len);
}
- table = svn_fs_fs__string_table_create(builder, pool);
+ table = svn_fs_x__string_table_create(builder, pool);
if (do_load_store)
SVN_ERR(store_and_load_table(&table, pool));
@@ -222,7 +225,7 @@ many_strings_table_body(svn_boolean_t do
{
apr_size_t len;
const char *string
- = svn_fs_fs__string_table_get(table, indexes[i], &len, pool);
+ = svn_fs_x__string_table_get(table, indexes[i], &len, pool);
SVN_TEST_STRING_ASSERT(string, strings[i]->data);
SVN_TEST_ASSERT(len == strlen(string));