static void
make_editor(const svn_delta_editor_t **editor,
void **edit_baton,
apr_bucket_brigade *bb,
dav_svn__output *output,
int compression_level,
int svndiff_version,
apr_pool_t *pool)
{
edit_baton_t *eb = apr_pcalloc(pool, sizeof(*eb));
svn_delta_editor_t *e = svn_delta_default_editor(pool);
eb->bb = bb;
eb->output = output;
eb->started = FALSE;
eb->sending_textdelta = FALSE;
eb->compression_level = compression_level;
eb->svndiff_version = svndiff_version;
e->set_target_revision = set_target_revision;
e->open_root = open_root;
e->delete_entry = delete_entry;
e->add_directory = add_directory;
e->open_directory = open_directory;
e->change_dir_prop = change_dir_prop;
e->add_file = add_file;
e->open_file = open_file;
e->apply_textdelta = apply_textdelta;
e->change_file_prop = change_file_prop;
e->close_file = close_file;
e->close_directory = close_directory;
*editor = e;
*edit_baton = eb;
}
static svn_error_t *
copy_foreign_dir(svn_ra_session_t *ra_session,
svn_client__pathrev_t *location,
svn_wc_context_t *wc_ctx,
const char *dst_abspath,
svn_depth_t depth,
svn_wc_notify_func2_t notify_func,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *scratch_pool)
{
struct edit_baton_t eb;
svn_delta_editor_t *editor = svn_delta_default_editor(scratch_pool);
const svn_delta_editor_t *wrapped_editor;
void *wrapped_baton;
const svn_ra_reporter3_t *reporter;
void *reporter_baton;
eb.pool = scratch_pool;
eb.anchor_abspath = dst_abspath;
eb.wc_ctx = wc_ctx;
eb.notify_func = notify_func;
eb.notify_baton = notify_baton;
editor->open_root = edit_open;
editor->close_edit = edit_close;
editor->add_directory = dir_add;
editor->change_dir_prop = dir_change_prop;
editor->close_directory = dir_close;
editor->add_file = file_add;
editor->change_file_prop = file_change_prop;
editor->apply_textdelta = file_textdelta;
editor->close_file = file_close;
SVN_ERR(svn_delta_get_cancellation_editor(cancel_func, cancel_baton,
editor, &eb,
&wrapped_editor, &wrapped_baton,
scratch_pool));
SVN_ERR(svn_ra_do_update3(ra_session, &reporter, &reporter_baton,
location->rev, "", svn_depth_infinity,
FALSE, FALSE, wrapped_editor, wrapped_baton,
scratch_pool, scratch_pool));
SVN_ERR(reporter->set_path(reporter_baton, "", location->rev, depth,
TRUE /* incomplete */,
NULL, scratch_pool));
SVN_ERR(reporter->finish_report(reporter_baton, scratch_pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_delta_depth_filter_editor(const svn_delta_editor_t **editor,
void **edit_baton,
const svn_delta_editor_t *wrapped_editor,
void *wrapped_edit_baton,
svn_depth_t requested_depth,
svn_boolean_t has_target,
apr_pool_t *pool)
{
svn_delta_editor_t *depth_filter_editor;
struct edit_baton *eb;
/* Easy out: if the caller wants infinite depth, there's nothing to
filter, so just return the editor we were supposed to wrap. And
if they've asked for an unknown depth, we can't possibly know
what that means, so why bother? */
if ((requested_depth == svn_depth_unknown)
|| (requested_depth == svn_depth_infinity))
{
*editor = wrapped_editor;
*edit_baton = wrapped_edit_baton;
return SVN_NO_ERROR;
}
depth_filter_editor = svn_delta_default_editor(pool);
depth_filter_editor->set_target_revision = set_target_revision;
depth_filter_editor->open_root = open_root;
depth_filter_editor->delete_entry = delete_entry;
depth_filter_editor->add_directory = add_directory;
depth_filter_editor->open_directory = open_directory;
depth_filter_editor->change_dir_prop = change_dir_prop;
depth_filter_editor->close_directory = close_directory;
depth_filter_editor->absent_directory = absent_directory;
depth_filter_editor->add_file = add_file;
depth_filter_editor->open_file = open_file;
depth_filter_editor->apply_textdelta = apply_textdelta;
depth_filter_editor->change_file_prop = change_file_prop;
depth_filter_editor->close_file = close_file;
depth_filter_editor->absent_file = absent_file;
depth_filter_editor->close_edit = close_edit;
eb = apr_palloc(pool, sizeof(*eb));
eb->wrapped_editor = wrapped_editor;
eb->wrapped_edit_baton = wrapped_edit_baton;
eb->has_target = has_target;
eb->requested_depth = requested_depth;
*editor = depth_filter_editor;
*edit_baton = eb;
return SVN_NO_ERROR;
}
svn_error_t *
svn_delta_get_cancellation_editor(svn_cancel_func_t cancel_func,
void *cancel_baton,
const svn_delta_editor_t *wrapped_editor,
void *wrapped_edit_baton,
const svn_delta_editor_t **editor,
void **edit_baton,
apr_pool_t *pool)
{
if (cancel_func)
{
svn_delta_editor_t *tree_editor = svn_delta_default_editor(pool);
struct edit_baton *eb = apr_palloc(pool, sizeof(*eb));
tree_editor->set_target_revision = set_target_revision;
tree_editor->open_root = open_root;
tree_editor->delete_entry = delete_entry;
tree_editor->add_directory = add_directory;
tree_editor->open_directory = open_directory;
tree_editor->change_dir_prop = change_dir_prop;
tree_editor->close_directory = close_directory;
tree_editor->absent_directory = absent_directory;
tree_editor->add_file = add_file;
tree_editor->open_file = open_file;
tree_editor->apply_textdelta = apply_textdelta;
tree_editor->change_file_prop = change_file_prop;
tree_editor->close_file = close_file;
tree_editor->absent_file = absent_file;
tree_editor->close_edit = close_edit;
tree_editor->abort_edit = abort_edit;
eb->wrapped_editor = wrapped_editor;
eb->wrapped_edit_baton = wrapped_edit_baton;
eb->cancel_func = cancel_func;
eb->cancel_baton = cancel_baton;
*editor = tree_editor;
*edit_baton = eb;
}
else
{
*editor = wrapped_editor;
*edit_baton = wrapped_edit_baton;
}
return SVN_NO_ERROR;
}
static svn_error_t *
get_dump_editor(const svn_delta_editor_t **editor,
void **edit_baton,
svn_fs_t *fs,
svn_revnum_t to_rev,
const char *root_path,
svn_stream_t *stream,
svn_repos_notify_func_t notify_func,
void *notify_baton,
svn_revnum_t oldest_dumped_rev,
svn_boolean_t use_deltas,
svn_boolean_t verify,
apr_pool_t *pool)
{
/* Allocate an edit baton to be stored in every directory baton.
Set it up for the directory baton we create here, which is the
root baton. */
struct edit_baton *eb = apr_pcalloc(pool, sizeof(*eb));
svn_delta_editor_t *dump_editor = svn_delta_default_editor(pool);
/* Set up the edit baton. */
eb->stream = stream;
eb->notify_func = notify_func;
eb->notify_baton = notify_baton;
eb->oldest_dumped_rev = oldest_dumped_rev;
eb->bufsize = sizeof(eb->buffer);
eb->path = apr_pstrdup(pool, root_path);
SVN_ERR(svn_fs_revision_root(&(eb->fs_root), fs, to_rev, pool));
eb->current_rev = to_rev;
eb->use_deltas = use_deltas;
eb->verify = verify;
/* Set up the editor. */
dump_editor->open_root = open_root;
dump_editor->delete_entry = delete_entry;
dump_editor->add_directory = add_directory;
dump_editor->open_directory = open_directory;
dump_editor->close_directory = close_directory;
dump_editor->change_dir_prop = change_dir_prop;
dump_editor->add_file = add_file;
dump_editor->open_file = open_file;
*edit_baton = eb;
*editor = dump_editor;
return SVN_NO_ERROR;
}
svn_error_t *
svn_client__wc_editor_internal(const svn_delta_editor_t **editor_p,
void **edit_baton_p,
const char *dst_abspath,
svn_boolean_t root_dir_add,
svn_boolean_t ignore_mergeinfo_changes,
svn_wc_notify_func2_t notify_func,
void *notify_baton,
svn_ra_session_t *ra_session,
svn_client_ctx_t *ctx,
apr_pool_t *result_pool)
{
svn_delta_editor_t *editor = svn_delta_default_editor(result_pool);
struct edit_baton_t *eb = apr_pcalloc(result_pool, sizeof(*eb));
eb->pool = result_pool;
eb->anchor_abspath = apr_pstrdup(result_pool, dst_abspath);
eb->root_dir_add = root_dir_add;
eb->ignore_mergeinfo_changes = ignore_mergeinfo_changes;
eb->ra_session = ra_session;
eb->wc_ctx = ctx->wc_ctx;
eb->ctx = ctx;
eb->notify_func = notify_func;
eb->notify_baton = notify_baton;
editor->open_root = edit_open;
editor->close_edit = edit_close;
editor->delete_entry = delete_entry;
editor->open_directory = dir_open;
editor->add_directory = dir_add;
editor->change_dir_prop = dir_change_prop;
editor->close_directory = dir_close;
editor->open_file = file_open;
editor->add_file = file_add;
editor->change_file_prop = file_change_prop;
editor->apply_textdelta = file_textdelta;
editor->close_file = file_close;
*editor_p = editor;
*edit_baton_p = eb;
return SVN_NO_ERROR;
}
svn_error_t *
svn_delta__get_debug_editor(const svn_delta_editor_t **editor,
void **edit_baton,
const svn_delta_editor_t *wrapped_editor,
void *wrapped_edit_baton,
apr_pool_t *pool)
{
svn_delta_editor_t *tree_editor = svn_delta_default_editor(pool);
struct edit_baton *eb = apr_palloc(pool, sizeof(*eb));
apr_file_t *errfp;
svn_stream_t *out;
apr_status_t apr_err = apr_file_open_stderr(&errfp, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, "Problem opening stderr");
out = svn_stream_from_aprfile2(errfp, TRUE, pool);
tree_editor->set_target_revision = set_target_revision;
tree_editor->open_root = open_root;
tree_editor->delete_entry = delete_entry;
tree_editor->add_directory = add_directory;
tree_editor->open_directory = open_directory;
tree_editor->change_dir_prop = change_dir_prop;
tree_editor->close_directory = close_directory;
tree_editor->absent_directory = absent_directory;
tree_editor->add_file = add_file;
tree_editor->open_file = open_file;
tree_editor->apply_textdelta = apply_textdelta;
tree_editor->change_file_prop = change_file_prop;
tree_editor->close_file = close_file;
tree_editor->absent_file = absent_file;
tree_editor->close_edit = close_edit;
eb->wrapped_editor = wrapped_editor;
eb->wrapped_edit_baton = wrapped_edit_baton;
eb->out = out;
eb->indent_level = 0;
*editor = tree_editor;
*edit_baton = eb;
return SVN_NO_ERROR;
}
/* Sets up a delta editor for dumping a revision */
void delta_setup_editor(session_t *session, dump_options_t *options, list_t *logs, log_revision_t *log_revision, svn_revnum_t local_revnum, svn_delta_editor_t **editor, void **editor_baton, apr_pool_t *pool)
{
de_baton_t *baton;
*editor = svn_delta_default_editor(pool);
(*editor)->set_target_revision = de_set_target_revision;
(*editor)->open_root = de_open_root;
(*editor)->delete_entry = de_delete_entry;
(*editor)->add_directory = de_add_directory;
(*editor)->open_directory = de_open_directory;
(*editor)->add_file = de_add_file;
(*editor)->open_file = de_open_file;
(*editor)->apply_textdelta = de_apply_textdelta;
(*editor)->close_file = de_close_file;
(*editor)->close_directory = de_close_directory;
(*editor)->change_file_prop = de_change_file_prop;
(*editor)->change_dir_prop = de_change_dir_prop;
(*editor)->close_edit = de_close_edit;
(*editor)->absent_directory = de_absent_directory;
(*editor)->absent_file = de_absent_file;
(*editor)->abort_edit = de_abort_edit;
baton = apr_palloc(pool, sizeof(de_baton_t));
baton->session = session;
baton->opts = options;
baton->logs = logs;
baton->log_revision = log_revision;
baton->local_revnum = local_revnum;
baton->revision_pool = svn_pool_create(pool);
baton->dumped_entries = apr_hash_make(baton->revision_pool);
*editor_baton = baton;
/* Create global hashes if needed */
if (!hashes_created) {
apr_pool_t *hash_pool = svn_pool_create(session->pool);
md5_hash = rhash_make(hash_pool);
delta_hash = rhash_make(hash_pool);
prop_hash = rhash_make(hash_pool);
hashes_created = 1;
}
}
/* Create a repository diff summarize editor and baton. */
svn_error_t *
svn_client__get_diff_summarize_editor(const char *target,
svn_client_diff_summarize_func_t
summarize_func,
void *summarize_baton,
svn_ra_session_t *ra_session,
svn_revnum_t revision,
svn_cancel_func_t cancel_func,
void *cancel_baton,
const svn_delta_editor_t **editor,
void **edit_baton,
apr_pool_t *pool)
{
svn_delta_editor_t *tree_editor = svn_delta_default_editor(pool);
struct edit_baton *eb = apr_palloc(pool, sizeof(*eb));
eb->target = target;
eb->summarize_func = summarize_func;
eb->summarize_func_baton = summarize_baton;
eb->ra_session = ra_session;
eb->revision = revision;
eb->walk_deleted_repos_dirs = TRUE;
eb->cancel_func = cancel_func;
eb->cancel_baton = cancel_baton;
tree_editor->open_root = open_root;
tree_editor->delete_entry = delete_entry;
tree_editor->add_directory = add_directory;
tree_editor->open_directory = open_directory;
tree_editor->change_dir_prop = change_prop;
tree_editor->close_directory = close_directory;
tree_editor->add_file = add_file;
tree_editor->open_file = open_file;
tree_editor->apply_textdelta = apply_textdelta;
tree_editor->change_file_prop = change_prop;
tree_editor->close_file = close_file;
return svn_delta_get_cancellation_editor(cancel_func, cancel_baton,
tree_editor, eb, editor, edit_baton,
pool);
}
void svn_ra_svn_get_editor(const svn_delta_editor_t **editor,
void **edit_baton, svn_ra_svn_conn_t *conn,
apr_pool_t *pool,
svn_ra_svn_edit_callback callback,
void *callback_baton)
{
svn_delta_editor_t *ra_svn_editor = svn_delta_default_editor(pool);
ra_svn_edit_baton_t *eb;
eb = apr_palloc(pool, sizeof(*eb));
eb->conn = conn;
eb->callback = callback;
eb->callback_baton = callback_baton;
eb->next_token = 0;
eb->got_status = FALSE;
ra_svn_editor->set_target_revision = ra_svn_target_rev;
ra_svn_editor->open_root = ra_svn_open_root;
ra_svn_editor->delete_entry = ra_svn_delete_entry;
ra_svn_editor->add_directory = ra_svn_add_dir;
ra_svn_editor->open_directory = ra_svn_open_dir;
ra_svn_editor->change_dir_prop = ra_svn_change_dir_prop;
ra_svn_editor->close_directory = ra_svn_close_dir;
ra_svn_editor->absent_directory = ra_svn_absent_dir;
ra_svn_editor->add_file = ra_svn_add_file;
ra_svn_editor->open_file = ra_svn_open_file;
ra_svn_editor->apply_textdelta = ra_svn_apply_textdelta;
ra_svn_editor->change_file_prop = ra_svn_change_file_prop;
ra_svn_editor->close_file = ra_svn_close_file;
ra_svn_editor->absent_file = ra_svn_absent_file;
ra_svn_editor->close_edit = ra_svn_close_edit;
ra_svn_editor->abort_edit = ra_svn_abort_edit;
*editor = ra_svn_editor;
*edit_baton = eb;
svn_error_clear(svn_editor__insert_shims(editor, edit_baton, *editor,
*edit_baton, NULL, NULL,
conn->shim_callbacks,
pool, pool));
}
svn_error_t *
dir_delta_get_editor(const svn_delta_editor_t **editor,
void **edit_baton,
svn_fs_t *fs,
svn_fs_root_t *txn_root,
const char *path,
apr_pool_t *pool)
{
svn_delta_editor_t *my_editor;
struct edit_baton *my_edit_baton;
/* Wondering why we don't include test_close_directory,
test_close_file, test_absent_directory, and test_absent_file
here...? -kfogel, 3 Nov 2003 */
/* Set up the editor. */
my_editor = svn_delta_default_editor(pool);
my_editor->open_root = test_open_root;
my_editor->delete_entry = test_delete_entry;
my_editor->add_directory = test_add_directory;
my_editor->open_directory = test_open_directory;
my_editor->add_file = test_add_file;
my_editor->open_file = test_open_file;
my_editor->apply_textdelta = test_apply_textdelta;
my_editor->change_file_prop = test_change_file_prop;
my_editor->change_dir_prop = test_change_dir_prop;
/* Set up the edit baton. */
my_edit_baton = apr_pcalloc(pool, sizeof(*my_edit_baton));
my_edit_baton->root_path = apr_pstrdup(pool, path);
my_edit_baton->pool = pool;
my_edit_baton->fs = fs;
my_edit_baton->txn_root = txn_root;
*editor = my_editor;
*edit_baton = my_edit_baton;
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_node_editor(const svn_delta_editor_t **editor,
void **edit_baton,
svn_repos_t *repos,
svn_fs_root_t *base_root,
svn_fs_root_t *root,
apr_pool_t *node_pool,
apr_pool_t *pool)
{
svn_delta_editor_t *my_editor;
struct edit_baton *my_edit_baton;
/* Set up the editor. */
my_editor = svn_delta_default_editor(pool);
my_editor->open_root = open_root;
my_editor->delete_entry = delete_entry;
my_editor->add_directory = add_directory;
my_editor->open_directory = open_directory;
my_editor->add_file = add_file;
my_editor->open_file = open_file;
my_editor->apply_textdelta = apply_textdelta;
my_editor->change_file_prop = change_node_prop;
my_editor->change_dir_prop = change_node_prop;
/* Set up the edit baton. */
my_edit_baton = apr_pcalloc(pool, sizeof(*my_edit_baton));
my_edit_baton->node_pool = node_pool;
my_edit_baton->fs = repos->fs;
my_edit_baton->root = root;
my_edit_baton->base_root = base_root;
*editor = my_editor;
*edit_baton = my_edit_baton;
return SVN_NO_ERROR;
}
static svn_error_t *
bench_null_export(svn_revnum_t *result_rev,
const char *from_path_or_url,
svn_opt_revision_t *peg_revision,
svn_opt_revision_t *revision,
svn_depth_t depth,
void *baton,
svn_client_ctx_t *ctx,
svn_boolean_t quiet,
apr_pool_t *pool)
{
svn_revnum_t edit_revision = SVN_INVALID_REVNUM;
svn_boolean_t from_is_url = svn_path_is_url(from_path_or_url);
SVN_ERR_ASSERT(peg_revision != NULL);
SVN_ERR_ASSERT(revision != NULL);
if (peg_revision->kind == svn_opt_revision_unspecified)
peg_revision->kind = svn_path_is_url(from_path_or_url)
? svn_opt_revision_head
: svn_opt_revision_working;
if (revision->kind == svn_opt_revision_unspecified)
revision = peg_revision;
if (from_is_url || ! SVN_CLIENT__REVKIND_IS_LOCAL_TO_WC(revision->kind))
{
svn_client__pathrev_t *loc;
svn_ra_session_t *ra_session;
svn_node_kind_t kind;
/* Get the RA connection. */
SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &loc,
from_path_or_url, NULL,
peg_revision,
revision, ctx, pool));
SVN_ERR(svn_ra_check_path(ra_session, "", loc->rev, &kind, pool));
if (kind == svn_node_file)
{
apr_hash_t *props;
/* Since you cannot actually root an editor at a file, we
* manually drive a few functions of our editor. */
/* Step outside the editor-likeness for a moment, to actually talk
* to the repository. */
/* ### note: the stream will not be closed */
SVN_ERR(svn_ra_get_file(ra_session, "", loc->rev,
svn_stream_empty(pool),
NULL, &props, pool));
}
else if (kind == svn_node_dir)
{
void *edit_baton = NULL;
const svn_delta_editor_t *export_editor = NULL;
const svn_ra_reporter3_t *reporter;
void *report_baton;
svn_delta_editor_t *editor = svn_delta_default_editor(pool);
editor->set_target_revision = set_target_revision;
editor->open_root = open_root;
editor->add_directory = add_directory;
editor->add_file = add_file;
editor->apply_textdelta = apply_textdelta;
editor->close_file = close_file;
editor->change_file_prop = change_file_prop;
editor->change_dir_prop = change_dir_prop;
/* for ra_svn, we don't need an editior in quiet mode */
if (!quiet || strncmp(loc->repos_root_url, "svn:", 4))
SVN_ERR(svn_delta_get_cancellation_editor(ctx->cancel_func,
ctx->cancel_baton,
editor,
baton,
&export_editor,
&edit_baton,
pool));
/* Manufacture a basic 'report' to the update reporter. */
SVN_ERR(svn_ra_do_update3(ra_session,
&reporter, &report_baton,
loc->rev,
"", /* no sub-target */
depth,
FALSE, /* don't want copyfrom-args */
FALSE, /* don't want ignore_ancestry */
export_editor, edit_baton,
pool, pool));
SVN_ERR(reporter->set_path(report_baton, "", loc->rev,
/* Depth is irrelevant, as we're
passing start_empty=TRUE anyway. */
svn_depth_infinity,
TRUE, /* "help, my dir is empty!" */
NULL, pool));
SVN_ERR(reporter->finish_report(report_baton, pool));
}
else if (kind == svn_node_none)
{
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("URL '%s' doesn't exist"),
from_path_or_url);
}
/* kind == svn_node_unknown not handled */
}
if (result_rev)
*result_rev = edit_revision;
return SVN_NO_ERROR;
}
svn_error_t *
svnsync_get_sync_editor(const svn_delta_editor_t *wrapped_editor,
void *wrapped_edit_baton,
svn_revnum_t base_revision,
const char *to_url,
const char *source_prop_encoding,
svn_boolean_t quiet,
const svn_delta_editor_t **editor,
void **edit_baton,
int *normalized_node_props_counter,
apr_pool_t *pool)
{
svn_delta_editor_t *tree_editor = svn_delta_default_editor(pool);
edit_baton_t *eb = apr_pcalloc(pool, sizeof(*eb));
tree_editor->set_target_revision = set_target_revision;
tree_editor->open_root = open_root;
tree_editor->delete_entry = delete_entry;
tree_editor->add_directory = add_directory;
tree_editor->open_directory = open_directory;
tree_editor->change_dir_prop = change_dir_prop;
tree_editor->close_directory = close_directory;
tree_editor->absent_directory = absent_directory;
tree_editor->add_file = add_file;
tree_editor->open_file = open_file;
tree_editor->apply_textdelta = apply_textdelta;
tree_editor->change_file_prop = change_file_prop;
tree_editor->close_file = close_file;
tree_editor->absent_file = absent_file;
tree_editor->close_edit = close_edit;
tree_editor->abort_edit = abort_edit;
eb->wrapped_editor = wrapped_editor;
eb->wrapped_edit_baton = wrapped_edit_baton;
eb->base_revision = base_revision;
eb->to_url = to_url;
eb->source_prop_encoding = source_prop_encoding;
eb->quiet = quiet;
eb->normalized_node_props_counter = normalized_node_props_counter;
if (getenv("SVNSYNC_UNSUPPORTED_STRIP_MERGEINFO"))
{
eb->strip_mergeinfo = TRUE;
}
if (getenv("SVNSYNC_UNSUPPORTED_MIGRATE_SVNMERGE"))
{
/* Current we can't merge property values. That's only possible
if all the properties to be merged were always modified in
exactly the same revisions, or if we allow ourselves to
lookup the current state of properties in the sync
destination. So for now, migrating svnmerge.py data implies
stripping pre-existing svn:mergeinfo. */
/* ### FIXME: Do a real migration by consulting the mirror
### repository's HEAD propvalues and merging svn:mergeinfo,
### svnmerge-integrated, and svnmerge-blocked together. */
eb->migrate_svnmerge = TRUE;
eb->strip_mergeinfo = TRUE;
}
*editor = tree_editor;
*edit_baton = eb;
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_get_commit_editor5(const svn_delta_editor_t **editor,
void **edit_baton,
svn_repos_t *repos,
svn_fs_txn_t *txn,
const char *repos_url,
const char *base_path,
apr_hash_t *revprop_table,
svn_commit_callback2_t callback,
void *callback_baton,
svn_repos_authz_callback_t authz_callback,
void *authz_baton,
apr_pool_t *pool)
{
svn_delta_editor_t *e;
apr_pool_t *subpool = svn_pool_create(pool);
struct edit_baton *eb;
/* Do a global authz access lookup. Users with no write access
whatsoever to the repository don't get a commit editor. */
if (authz_callback)
{
svn_boolean_t allowed;
SVN_ERR(authz_callback(svn_authz_write, &allowed, NULL, NULL,
authz_baton, pool));
if (!allowed)
return svn_error_create(SVN_ERR_AUTHZ_UNWRITABLE, NULL,
"Not authorized to open a commit editor.");
}
/* Allocate the structures. */
e = svn_delta_default_editor(pool);
eb = apr_pcalloc(subpool, sizeof(*eb));
/* Set up the editor. */
e->open_root = open_root;
e->delete_entry = delete_entry;
e->add_directory = add_directory;
e->open_directory = open_directory;
e->change_dir_prop = change_dir_prop;
e->add_file = add_file;
e->open_file = open_file;
e->close_file = close_file;
e->apply_textdelta = apply_textdelta;
e->change_file_prop = change_file_prop;
e->close_edit = close_edit;
e->abort_edit = abort_edit;
/* Set up the edit baton. */
eb->pool = subpool;
eb->revprop_table = svn_prop_hash_dup(revprop_table, subpool);
eb->commit_callback = callback;
eb->commit_callback_baton = callback_baton;
eb->authz_callback = authz_callback;
eb->authz_baton = authz_baton;
eb->base_path = svn_fspath__canonicalize(base_path, subpool);
eb->repos = repos;
eb->repos_url = repos_url;
eb->repos_name = svn_dirent_basename(svn_repos_path(repos, subpool),
subpool);
eb->fs = svn_repos_fs(repos);
eb->txn = txn;
eb->txn_owner = txn == NULL;
*edit_baton = eb;
*editor = e;
return SVN_NO_ERROR;
}
/* Create a repository diff editor and baton. */
svn_error_t *
svn_client__get_diff_editor(const svn_delta_editor_t **editor,
void **edit_baton,
svn_depth_t depth,
svn_ra_session_t *ra_session,
svn_revnum_t revision,
svn_boolean_t walk_deleted_dirs,
svn_boolean_t text_deltas,
const svn_wc_diff_callbacks4_t *diff_callbacks,
void *diff_cmd_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
svn_wc_notify_func2_t notify_func,
void *notify_baton,
apr_pool_t *result_pool)
{
apr_pool_t *editor_pool = svn_pool_create(result_pool);
svn_delta_editor_t *tree_editor = svn_delta_default_editor(editor_pool);
struct edit_baton *eb = apr_pcalloc(editor_pool, sizeof(*eb));
svn_delta_shim_callbacks_t *shim_callbacks =
svn_delta_shim_callbacks_default(editor_pool);
eb->pool = editor_pool;
eb->depth = depth;
eb->diff_callbacks = diff_callbacks;
eb->diff_cmd_baton = diff_cmd_baton;
eb->ra_session = ra_session;
eb->revision = revision;
eb->empty_file = NULL;
eb->empty_hash = apr_hash_make(eb->pool);
eb->deleted_paths = apr_hash_make(eb->pool);
eb->notify_func = notify_func;
eb->notify_baton = notify_baton;
eb->walk_deleted_repos_dirs = walk_deleted_dirs;
eb->text_deltas = text_deltas;
eb->cancel_func = cancel_func;
eb->cancel_baton = cancel_baton;
tree_editor->set_target_revision = set_target_revision;
tree_editor->open_root = open_root;
tree_editor->delete_entry = delete_entry;
tree_editor->add_directory = add_directory;
tree_editor->open_directory = open_directory;
tree_editor->add_file = add_file;
tree_editor->open_file = open_file;
tree_editor->apply_textdelta = apply_textdelta;
tree_editor->close_file = close_file;
tree_editor->close_directory = close_directory;
tree_editor->change_file_prop = change_file_prop;
tree_editor->change_dir_prop = change_dir_prop;
tree_editor->close_edit = close_edit;
tree_editor->absent_directory = absent_directory;
tree_editor->absent_file = absent_file;
SVN_ERR(svn_delta_get_cancellation_editor(cancel_func, cancel_baton,
tree_editor, eb,
editor, edit_baton,
eb->pool));
shim_callbacks->fetch_kind_func = fetch_kind_func;
shim_callbacks->fetch_props_func = fetch_props_func;
shim_callbacks->fetch_base_func = fetch_base_func;
shim_callbacks->fetch_baton = eb;
SVN_ERR(svn_editor__insert_shims(editor, edit_baton, *editor, *edit_baton,
shim_callbacks,
result_pool, result_pool));
return SVN_NO_ERROR;
}