std::vector<svn_revnum_t>
Client::update(const Targets & targets,
const Revision & revision,
bool recurse,
bool ignore_externals) throw(ClientException)
{
Pool pool;
apr_array_header_t * result_revs;
svn_error_t * error =
svn_client_update2(&result_revs,
const_cast<apr_array_header_t*>(targets.array(pool)),
revision.revision(),
recurse,
ignore_externals,
*m_context,
pool);
if (error != NULL)
throw ClientException(error);
std::vector<svn_revnum_t> revnums;
int i;
for (i = 0; i < result_revs->nelts; i++)
{
svn_revnum_t revnum=
APR_ARRAY_IDX(result_revs, i, svn_revnum_t);
revnums.push_back(revnum);
}
return revnums;
}
std::pair<svn_revnum_t,std::string>
Client::revpropget(const char *propName,
const Path &path,
const Revision &revision)
{
Pool pool;
svn_string_t *propval;
svn_revnum_t revnum;
svn_error_t * error =
svn_client_revprop_get(propName,
&propval,
path.c_str(),
revision.revision(),
&revnum,
*m_context,
pool);
if (error != nullptr)
{
throw ClientException(error);
}
// if the property does not exist NULL is returned
if (propval == nullptr)
return std::pair<svn_revnum_t,std::string> (0, std::string());
return std::pair<svn_revnum_t,std::string> (revnum, std::string(propval->data));
}
std::string
Client::cat(const Path & path,
const Revision & revision,
const Revision & peg_revision) throw(ClientException)
{
Pool pool;
svn_stringbuf_t * stringbuf = svn_stringbuf_create("", pool);
svn_stream_t * stream = svn_stream_from_stringbuf(stringbuf, pool);
svn_error_t * error;
error = svn_client_cat2(stream,
path.c_str(),
peg_revision.revision(),
revision.revision(),
*m_context,
pool);
if (error != 0)
throw ClientException(error);
return std::string(stringbuf->data, stringbuf->len);
}
InfoVector
Client::info(const Path & pathOrUrl,
bool recurse,
const Revision & revision,
const Revision & pegRevision) throw(ClientException)
{
Pool pool;
InfoVector infoVector;
svn_error_t * error =
svn_client_info(pathOrUrl.c_str(),
pegRevision.revision(),
revision.revision(),
infoReceiverFunc,
&infoVector,
recurse,
*m_context,
pool);
if (error != 0)
throw ClientException(error);
return infoVector;
}
/**
* lists properties in @a path no matter whether local or
* repository
*
* @param path
* @param revision
* @param recurse
* @return PropertiesList
*/
PathPropertiesMapList
Client::proplist(const Path & path,
const Revision & revision,
bool recurse)
{
Pool pool;
apr_array_header_t * props;
svn_error_t * error =
svn_client_proplist(&props,
path.c_str(),
revision.revision(),
recurse,
*m_context,
pool);
if (error != nullptr)
{
throw ClientException(error);
}
PathPropertiesMapList path_prop_map_list;
for (int j = 0; j < props->nelts; ++j)
{
svn_client_proplist_item_t *item =
((svn_client_proplist_item_t **)props->elts)[j];
PropertiesMap prop_map;
apr_hash_index_t *hi;
for (hi = apr_hash_first(pool, item->prop_hash); hi;
hi = apr_hash_next(hi))
{
const void *key;
void *val;
apr_hash_this(hi, &key, nullptr, &val);
prop_map [std::string((const char *)key)] =
std::string(((const svn_string_t *)val)->data);
}
path_prop_map_list.push_back(PathPropertiesMapEntry(item->node_name->data, prop_map));
}
return path_prop_map_list;
}
void
Client::copy(const Path & srcPath,
const Revision & srcRevision,
const Path & destPath) throw(ClientException)
{
Pool pool;
svn_client_commit_info_t *commit_info = NULL;
svn_error_t * error =
svn_client_copy(&commit_info,
srcPath.c_str(),
srcRevision.revision(),
destPath.c_str(),
*m_context,
pool);
if (error != NULL)
throw ClientException(error);
}
PathPropertiesMapList
Client::propget(const char *propName,
const Path &path,
const Revision &revision,
bool recurse)
{
Pool pool;
apr_hash_t *props;
svn_error_t * error =
svn_client_propget(&props,
propName,
path.c_str(),
revision.revision(),
recurse,
*m_context,
pool);
if (error != nullptr)
{
throw ClientException(error);
}
PathPropertiesMapList path_prop_map_list;
apr_hash_index_t *hi;
for (hi = apr_hash_first(pool, props); hi;
hi = apr_hash_next(hi))
{
PropertiesMap prop_map;
const void *key;
void *val;
apr_hash_this(hi, &key, nullptr, &val);
prop_map [std::string(propName)] = std::string(((const svn_string_t *)val)->data);
path_prop_map_list.push_back(PathPropertiesMapEntry((const char *)key, prop_map));
}
return path_prop_map_list;
}
void SVNRepos::deltify(File &path, Revision &revStart, Revision &revEnd)
{
SVN::Pool requestPool;
svn_repos_t *repos;
svn_fs_t *fs;
svn_revnum_t start = SVN_INVALID_REVNUM, end = SVN_INVALID_REVNUM;
svn_revnum_t youngest, revision;
SVN::Pool revisionPool;
if (path.isNull())
{
JNIUtil::throwNullPointerException("path");
return;
}
SVN_JNI_ERR(svn_repos_open3(&repos,
path.getInternalStyle(requestPool), NULL,
requestPool.getPool(),
requestPool.getPool()), );
fs = svn_repos_fs(repos);
SVN_JNI_ERR(svn_fs_youngest_rev(&youngest, fs, requestPool.getPool()), );
if (revStart.revision()->kind == svn_opt_revision_number)
/* ### We only handle revision numbers right now, not dates. */
start = revStart.revision()->value.number;
else if (revStart.revision()->kind == svn_opt_revision_head)
start = youngest;
else
start = SVN_INVALID_REVNUM;
if (revEnd.revision()->kind == svn_opt_revision_number)
end = revEnd.revision()->value.number;
else if (revEnd.revision()->kind == svn_opt_revision_head)
end = youngest;
else
end = SVN_INVALID_REVNUM;
/* Fill in implied revisions if necessary. */
if (start == SVN_INVALID_REVNUM)
start = youngest;
if (end == SVN_INVALID_REVNUM)
end = start;
if (start > end)
{
SVN_JNI_ERR(svn_error_create
(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("First revision cannot be higher than second")), );
}
svn_revnum_t
Client::doSwitch(const Path & path,
const char * url,
const Revision & revision,
bool recurse) throw(ClientException)
{
Pool pool;
svn_revnum_t revnum = 0;
svn_error_t * error =
svn_client_switch(&revnum,
path.c_str(),
url,
revision.revision(),
recurse,
*m_context,
pool);
if (error != NULL)
throw ClientException(error);
return revnum;
}
/**
* delete property in @a path no matter whether local or
* repository
*
* @param path
* @param revision
* @param propName
* @param propValue
* @param recurse
* @param revprop
* @return PropertiesList
*/
svn_revnum_t
Client::revpropdel(const char *propName,
const Path &path,
const Revision &revision,
bool force)
{
Pool pool;
svn_revnum_t revnum;
svn_error_t * error =
svn_client_revprop_set(propName,
nullptr, // value = NULL
path.c_str(),
revision.revision(),
&revnum,
force,
*m_context,
pool);
if (error != nullptr)
throw ClientException(error);
return revnum;
}
/**
* lists revision properties in @a path no matter whether local or
* repository
*
* @param path
* @param revision
* @param recurse
* @return PropertiesList
*/
std::pair<svn_revnum_t,PropertiesMap>
Client::revproplist(const Path &path,
const Revision &revision)
{
Pool pool;
apr_hash_t * props;
svn_revnum_t revnum;
svn_error_t * error =
svn_client_revprop_list(&props,
path.c_str(),
revision.revision(),
&revnum,
*m_context,
pool);
if (error != nullptr)
{
throw ClientException(error);
}
PropertiesMap prop_map;
apr_hash_index_t *hi;
for (hi = apr_hash_first(pool, props); hi;
hi = apr_hash_next(hi))
{
const void *key;
void *val;
apr_hash_this(hi, &key, nullptr, &val);
prop_map [std::string((const char *)key)] =
std::string(((const svn_string_t *)val)->data);
}
return std::pair<svn_revnum_t,PropertiesMap> (revnum, prop_map);
}
void SVNAdmin::deltify(const char *path, Revision &revStart, Revision &revEnd)
{
Pool requestPool;
SVN_JNI_NULL_PTR_EX(path, "path", );
path = svn_path_internal_style(path, requestPool.pool());
svn_repos_t *repos;
svn_fs_t *fs;
svn_revnum_t start = SVN_INVALID_REVNUM, end = SVN_INVALID_REVNUM;
svn_revnum_t youngest, revision;
Pool revisionPool;
SVN_JNI_ERR(svn_repos_open(&repos, path, requestPool.pool()), );
fs = svn_repos_fs (repos);
SVN_JNI_ERR(svn_fs_youngest_rev(&youngest, fs, requestPool.pool()), );
if (revStart.revision()->kind == svn_opt_revision_number)
/* ### We only handle revision numbers right now, not dates. */
start = revStart.revision()->value.number;
else if (revStart.revision()->kind == svn_opt_revision_head)
start = youngest;
else
start = SVN_INVALID_REVNUM;
if (revEnd.revision()->kind == svn_opt_revision_number)
end = revEnd.revision()->value.number;
else if (revEnd.revision()->kind == svn_opt_revision_head)
end = youngest;
else
end = SVN_INVALID_REVNUM;
/* Fill in implied revisions if necessary. */
if (start == SVN_INVALID_REVNUM)
start = youngest;
if (end == SVN_INVALID_REVNUM)
end = start;
if (start > end)
{
SVN_JNI_ERR(svn_error_create
(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("First revision cannot be higher than second")), );
}
std::string
Client::diff(const Path & tmpPath, const Path & path,
const Revision & revision1, const Revision & revision2,
const bool recurse, const bool ignoreAncestry,
const bool noDiffDeleted) throw(ClientException)
{
Pool pool;
svn_error_t * error;
apr_status_t status;
apr_file_t * outfile = nullptr;
const char * outfileName = nullptr;
apr_file_t * errfile = nullptr;
const char * errfileName = nullptr;
apr_array_header_t * options;
svn_stringbuf_t * stringbuf;
// svn_client_diff needs an options array, even if it is empty
options = apr_array_make(pool, 0, 0);
// svn_client_diff needs a temporary file to write diff output to
error = svn_io_open_unique_file(&outfile, &outfileName,
tmpPath.c_str(), ".tmp",
false, pool);
if (error != nullptr)
{
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
throw ClientException(error);
}
// and another one to write errors to
error = svn_io_open_unique_file(&errfile, &errfileName,
tmpPath.c_str(), ".tmp",
false, pool);
if (error != nullptr)
{
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
throw ClientException(error);
}
// run diff
error = svn_client_diff(options,
path.c_str(), revision1.revision(),
path.c_str(), revision2.revision(),
recurse, ignoreAncestry, noDiffDeleted,
outfile, errfile,
*m_context,
pool);
if (error != nullptr)
{
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
throw ClientException(error);
}
// then we reopen outfile for reading
status = apr_file_close(outfile);
if (status)
{
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
fail(pool, status, "failed to close '%s'", outfileName);
}
status = apr_file_open(&outfile, outfileName, APR_READ, APR_OS_DEFAULT, pool);
if (status)
{
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
fail(pool, status, "failed to open '%s'", outfileName);
}
// now we can read the diff output from outfile and return that
error = svn_stringbuf_from_aprfile(&stringbuf, outfile, pool);
if (error != nullptr)
{
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
throw ClientException(error);
}
diffCleanup(outfile, outfileName, errfile, errfileName, pool);
return stringbuf->data;
}
Revision::Revision(const Revision & revision)
{
init(revision.revision());
}
