view release on metacpan or  search on metacpan

src/subversion/subversion/bindings/javahl/native/SVNRepos.cpp  view on Meta::CPAN

  /* Open the filesystem. */
  svn_repos_t *repos;
  SVN_JNI_ERR(svn_repos_open2(&repos, path.getInternalStyle(requestPool),
                              NULL, requestPool.getPool()), );

  /* If we are bypassing the hooks system, we just hit the filesystem
   * directly. */
  svn_error_t *err;
  svn_string_t *propValStr = svn_string_create(propValue,
                                               requestPool.getPool());
  if (usePreRevPropChangeHook || usePostRevPropChangeHook)
    {
      err = svn_repos_fs_change_rev_prop4(repos,
                                          revision.revision()->value.number,
                                          NULL, propName, NULL, propValStr,
                                          usePreRevPropChangeHook,
                                          usePostRevPropChangeHook, NULL,
                                          NULL, requestPool.getPool());
    }
  else
    {
      svn_fs_t *fs = svn_repos_fs(repos);
      err = svn_fs_change_rev_prop2(fs, revision.revision()->value.number,
                                    propName, NULL, propValStr,
                                    requestPool.getPool());
    }
  SVN_JNI_ERR(err, );
}

/* Set *REVNUM to the revision specified by REVISION (or to
   SVN_INVALID_REVNUM if that has the type 'unspecified'),
   possibly making use of the YOUNGEST revision number in REPOS. */
svn_error_t *
SVNRepos::getRevnum(svn_revnum_t *revnum, const svn_opt_revision_t *revision,
                    svn_revnum_t youngest, svn_repos_t *repos,
                    apr_pool_t *pool)
{
  if (revision->kind == svn_opt_revision_number)
    *revnum = revision->value.number;
  else if (revision->kind == svn_opt_revision_head)
    *revnum = youngest;
  else if (revision->kind == svn_opt_revision_date)
    SVN_ERR(svn_repos_dated_revision
            (revnum, repos, revision->value.date, pool));
  else if (revision->kind == svn_opt_revision_unspecified)
    *revnum = SVN_INVALID_REVNUM;
  else
    return svn_error_create
      (SVN_ERR_INCORRECT_PARAMS, NULL, _("Invalid revision specifier"));

  if (*revnum > youngest)
    return svn_error_createf
      (SVN_ERR_INCORRECT_PARAMS, NULL,
       _("Revisions must not be greater than the youngest revision (%ld)"),
       youngest);

  return SVN_NO_ERROR;
}

void
SVNRepos::verify(File &path, Revision &revisionStart, Revision &revisionEnd,
                 ReposNotifyCallback *notifyCallback)
{
  SVN::Pool requestPool;
  svn_repos_t *repos;
  svn_revnum_t lower = SVN_INVALID_REVNUM, upper = SVN_INVALID_REVNUM;
  svn_revnum_t youngest;

  if (path.isNull())
    {
      JNIUtil::throwNullPointerException("path");
      return;
    }

  /* This whole process is basically just a dump of the repository
   * with no interest in the output. */
  SVN_JNI_ERR(svn_repos_open2(&repos, path.getInternalStyle(requestPool),
                              NULL, requestPool.getPool()), );
  SVN_JNI_ERR(svn_fs_youngest_rev(&youngest, svn_repos_fs(repos),
                                  requestPool.getPool()), );

  /* Find the revision numbers at which to start and end. */
  SVN_JNI_ERR(getRevnum(&lower, revisionStart.revision(),
                        youngest, repos, requestPool.getPool()), );
  SVN_JNI_ERR(getRevnum(&upper, revisionEnd.revision(),
                        youngest, repos, requestPool.getPool()), );

  // Fill in implied revisions if necessary.
  if (lower == SVN_INVALID_REVNUM)
    {
      lower = 0;
      upper = youngest;
    }
  else if (upper == SVN_INVALID_REVNUM)
    {
      upper = lower;
    }

  if (lower > upper)
    SVN_JNI_ERR(svn_error_create
      (SVN_ERR_INCORRECT_PARAMS, NULL,
       _("Start revision cannot be higher than end revision")), );

  SVN_JNI_ERR(svn_repos_verify_fs2(repos, lower, upper,
                                   notifyCallback != NULL
                                    ? ReposNotifyCallback::notify
                                    : NULL,
                                   notifyCallback,
                                   checkCancel, this /* cancel callback/baton */,
                                   requestPool.getPool()), );
}

void SVNRepos::pack(File &path, ReposNotifyCallback *notifyCallback)
{
  SVN::Pool requestPool;
  svn_repos_t *repos;

  if (path.isNull())
    {
      JNIUtil::throwNullPointerException("path");
      return;
    }

  SVN_JNI_ERR(svn_repos_open2(&repos, path.getInternalStyle(requestPool),
                              NULL, requestPool.getPool()), );

  SVN_JNI_ERR(svn_repos_fs_pack2(repos,
                                 notifyCallback != NULL
                                    ? ReposNotifyCallback::notify
                                    : NULL,
                                 notifyCallback,
                                 checkCancel, this,
                                 requestPool.getPool()),
              );
}

void SVNRepos::upgrade(File &path, ReposNotifyCallback *notifyCallback)
{
  SVN::Pool requestPool;

  if (path.isNull())
    {
      JNIUtil::throwNullPointerException("path");
      return;
    }

  SVN_JNI_ERR(svn_repos_upgrade2(path.getInternalStyle(requestPool), FALSE,
                                 notifyCallback != NULL
                                    ? ReposNotifyCallback::notify
                                    : NULL,
                                 notifyCallback,
                                 requestPool.getPool()),
              );
}

jobject SVNRepos::lslocks(File &path, svn_depth_t depth)
{
  SVN::Pool requestPool;
  svn_repos_t *repos;
  apr_hash_t *locks;
  apr_hash_index_t *hi;

  if (path.isNull())
    {