File Manager

003 File Manager

Current Path: /usr/src/contrib/subversion/subversion/libsvn_wc

usr / src / contrib / subversion / subversion / libsvn_wc /

📁 ..
📄 README(9.5 KB)
📄 adm_crawler.c(52.36 KB)
📄 adm_files.c(20.21 KB)
📄 adm_files.h(5.34 KB)
📄 adm_ops.c(40.15 KB)
📄 ambient_depth_filter_editor.c(21.68 KB)
📄 cleanup.c(7.33 KB)
📄 conflicts.c(152.54 KB)
📄 conflicts.h(19.21 KB)
📄 context.c(3.43 KB)
📄 copy.c(45.56 KB)
📄 crop.c(14.47 KB)
📄 delete.c(19.04 KB)
📄 deprecated.c(172.72 KB)
📄 diff.h(7.02 KB)
📄 diff_editor.c(116.98 KB)
📄 diff_local.c(21.71 KB)
📄 entries.c(107.62 KB)
📄 entries.h(6.75 KB)
📄 externals.c(64.3 KB)
📄 info.c(20.66 KB)
📄 libsvn_wc.pc.in(367 B)
📄 lock.c(52.27 KB)
📄 lock.h(3.07 KB)
📄 merge.c(57.23 KB)
📄 node.c(42.65 KB)
📄 old-and-busted.c(42.24 KB)
📄 props.c(89.9 KB)
📄 props.h(5.98 KB)
📄 questions.c(26.96 KB)
📄 relocate.c(5.91 KB)
📄 revert.c(37.16 KB)
📄 revision_status.c(2.75 KB)
📄 status.c(107.72 KB)
📄 token-map.h(2.76 KB)
📄 translate.c(15.68 KB)
📄 translate.h(7.88 KB)
📄 tree_conflicts.c(17.78 KB)
📄 tree_conflicts.h(3.26 KB)
📄 update_editor.c(214.25 KB)
📄 upgrade.c(76.76 KB)
📄 util.c(16.9 KB)
📄 wc-checks.h(11.68 KB)
📄 wc-checks.sql(11.67 KB)
📄 wc-metadata.h(12.09 KB)
📄 wc-metadata.sql(29.67 KB)
📄 wc-queries.h(121.6 KB)
📄 wc-queries.sql(61.37 KB)
📄 wc.h(29.75 KB)
📄 wc_db.c(588.65 KB)
📄 wc_db.h(147.07 KB)
📄 wc_db_pristine.c(35.13 KB)
📄 wc_db_private.h(21.98 KB)
📄 wc_db_update_move.c(175.6 KB)
📄 wc_db_util.c(5.16 KB)
📄 wc_db_wcroot.c(35.78 KB)
📄 wcroot_anchor.c(8.75 KB)
📄 workqueue.c(59.76 KB)
📄 workqueue.h(9 KB)

Editing: crop.c

/*
 * crop.c: Cropping the WC
 *
 * ====================================================================
 *    Licensed to the Apache Software Foundation (ASF) under one
 *    or more contributor license agreements.  See the NOTICE file
 *    distributed with this work for additional information
 *    regarding copyright ownership.  The ASF licenses this file
 *    to you under the Apache License, Version 2.0 (the
 *    "License"); you may not use this file except in compliance
 *    with the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing,
 *    software distributed under the License is distributed on an
 *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *    KIND, either express or implied.  See the License for the
 *    specific language governing permissions and limitations
 *    under the License.
 * ====================================================================
 */

/* ==================================================================== */

#include "svn_wc.h"
#include "svn_pools.h"
#include "svn_error.h"
#include "svn_error_codes.h"
#include "svn_dirent_uri.h"
#include "svn_path.h"

#include "wc.h"
#include "workqueue.h"

#include "svn_private_config.h"

/* Helper function that crops the children of the LOCAL_ABSPATH, under the
 * constraint of NEW_DEPTH. The DIR_PATH itself will never be cropped. The
 * whole subtree should have been locked.
 *
 * DIR_DEPTH is the current depth of LOCAL_ABSPATH as stored in DB.
 *
 * If NOTIFY_FUNC is not null, each file and ROOT of subtree will be reported
 * upon remove.
 */
static svn_error_t *
crop_children(svn_wc__db_t *db,
              const char *local_abspath,
              svn_depth_t dir_depth,
              svn_depth_t new_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)
{
  const apr_array_header_t *children;
  apr_pool_t *iterpool;
  int i;

SVN_ERR_ASSERT(new_depth >= svn_depth_empty
                 && new_depth <= svn_depth_infinity);

if (cancel_func)
    SVN_ERR(cancel_func(cancel_baton));

iterpool = svn_pool_create(scratch_pool);

if (dir_depth == svn_depth_unknown)
    dir_depth = svn_depth_infinity;

/* Update the depth of target first, if needed. */
  if (dir_depth > new_depth)
    SVN_ERR(svn_wc__db_op_set_base_depth(db, local_abspath, new_depth,
                                         iterpool));

/* Looping over current directory's SVN entries: */
  SVN_ERR(svn_wc__db_base_get_children(&children, db, local_abspath,
                                       scratch_pool, iterpool));

for (i = 0; i < children->nelts; i++)
    {
      const char *child_name = APR_ARRAY_IDX(children, i, const char *);
      const char *child_abspath;
      svn_wc__db_status_t child_status;
      svn_node_kind_t kind;
      svn_depth_t child_depth;
      svn_boolean_t have_work;
      svn_depth_t remove_below;

svn_pool_clear(iterpool);

/* Get the next node */
      child_abspath = svn_dirent_join(local_abspath, child_name, iterpool);

SVN_ERR(svn_wc__db_read_info(&child_status, &kind, NULL, NULL, NULL,
                                   NULL,NULL, NULL, NULL, &child_depth,
                                   NULL, NULL, NULL, NULL, NULL, NULL,
                                   NULL, NULL, NULL, NULL, NULL, NULL,
                                   NULL, NULL, NULL, NULL, &have_work,
                                   db, child_abspath, iterpool, iterpool));

if (have_work)
        {
          svn_boolean_t modified, all_deletes;

if (child_status != svn_wc__db_status_deleted)
            {
              /* ### TODO: Check for issue #4636 constraints, but not only on
                     this node, but also at all its descendants: We don't want
                     to remove moved_from information here! */
              continue; /* Leave local additions alone */
            }

SVN_ERR(svn_wc__node_has_local_mods(&modified, &all_deletes,
                                              db, child_abspath, FALSE,
                                              cancel_func, cancel_baton,
                                              iterpool));

if (modified && !all_deletes)
            continue; /* Something interesting is still there */
        }

remove_below = (kind == svn_node_dir)
                       ? svn_depth_immediates
                       : svn_depth_files;

if ((child_status == svn_wc__db_status_server_excluded ||
           child_status == svn_wc__db_status_excluded ||
           child_status == svn_wc__db_status_not_present))
        {
          if (new_depth < remove_below)
            SVN_ERR(svn_wc__db_base_remove(db, child_abspath,
                                           FALSE /* keep_as_working */,
                                           FALSE, FALSE,
                                           SVN_INVALID_REVNUM,
                                           NULL, NULL, iterpool));

continue; /* No recurse */
        }

if (new_depth < remove_below)
        {
          svn_boolean_t modified, all_deletes;

if (!modified || all_deletes)
            {
              SVN_ERR(svn_wc__db_base_remove(db, child_abspath,
                                             FALSE, FALSE, FALSE,
                                             SVN_INVALID_REVNUM,
                                             NULL, NULL, iterpool));
              if (notify_func)
                {
                  svn_wc_notify_t *notify;
                  notify = svn_wc_create_notify(child_abspath,
                                                svn_wc_notify_delete,
                                                iterpool);
                  (*notify_func)(notify_baton, notify, iterpool);
                }

continue; /* No recurse */
            }

/* Fall through: recurse:*/
        }

if (kind == svn_node_dir)
        {
          SVN_ERR(crop_children(db, child_abspath,
                                child_depth, svn_depth_empty,
                                notify_func, notify_baton,
                                cancel_func, cancel_baton,
                                iterpool));
        }
    }

svn_pool_destroy(iterpool);

return SVN_NO_ERROR;
}

svn_error_t *
svn_wc_exclude(svn_wc_context_t *wc_ctx,
               const char *local_abspath,
               svn_cancel_func_t cancel_func,
               void *cancel_baton,
               svn_wc_notify_func2_t notify_func,
               void *notify_baton,
               apr_pool_t *scratch_pool)
{
  svn_boolean_t is_root, is_switched;
  svn_wc__db_status_t status;
  svn_node_kind_t kind;
  svn_revnum_t revision;
  svn_depth_t depth;
  svn_boolean_t modified, all_deletes;
  const char *repos_relpath, *repos_root, *repos_uuid;

SVN_ERR(svn_wc__db_is_switched(&is_root, &is_switched, NULL,
                                 wc_ctx->db, local_abspath, scratch_pool));

if (is_root)
    {
       return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
                                _("Cannot exclude '%s': "
                                  "it is a working copy root"),
                                svn_dirent_local_style(local_abspath,
                                                       scratch_pool));
    }
  if (is_switched)
    {
      return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
                               _("Cannot exclude '%s': "
                                 "it is a switched path"),
                               svn_dirent_local_style(local_abspath,
                                                      scratch_pool));
    }

SVN_ERR(svn_wc__db_read_info(&status, &kind, &revision, &repos_relpath,
                               &repos_root, &repos_uuid, NULL, NULL, NULL,
                               &depth, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
                               NULL, NULL, NULL, NULL, NULL, NULL, NULL,
                               NULL, NULL, NULL,
                               wc_ctx->db, local_abspath,
                               scratch_pool, scratch_pool));

switch (status)
    {
      case svn_wc__db_status_server_excluded:
      case svn_wc__db_status_excluded:
      case svn_wc__db_status_not_present:
        return svn_error_createf(SVN_ERR_WC_PATH_NOT_FOUND, NULL,
                                 _("The node '%s' was not found."),
                                 svn_dirent_local_style(local_abspath,
                                                        scratch_pool));

case svn_wc__db_status_added:
        /* Would have to check parents if we want to allow this */
        return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
                                 _("Cannot exclude '%s': it is to be added "
                                   "to the repository. Try commit instead"),
                                 svn_dirent_local_style(local_abspath,
                                                        scratch_pool));
      case svn_wc__db_status_deleted:
        /* Would have to check parents if we want to allow this */
        return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
                                 _("Cannot exclude '%s': it is to be deleted "
                                   "from the repository. Try commit instead"),
                                 svn_dirent_local_style(local_abspath,
                                                        scratch_pool));

case svn_wc__db_status_normal:
      case svn_wc__db_status_incomplete:
      default:
        break; /* Ok to exclude */
    }

SVN_ERR(svn_wc__node_has_local_mods(&modified, &all_deletes,
                                      wc_ctx->db, local_abspath, FALSE,
                                      cancel_func, cancel_baton,
                                      scratch_pool));

if (!modified || all_deletes)
    {
      /* Remove all working copy data below local_abspath */
      SVN_ERR(svn_wc__db_base_remove(wc_ctx->db, local_abspath,
                                     FALSE /* keep_working */,
                                     FALSE, TRUE,
                                     revision,
                                     NULL, NULL,
                                     scratch_pool));

SVN_ERR(svn_wc__wq_run(wc_ctx->db, local_abspath,
                             cancel_func, cancel_baton,
                             scratch_pool));

if (notify_func)
        {
          svn_wc_notify_t *notify;
          notify = svn_wc_create_notify(local_abspath,
                                        svn_wc_notify_exclude,
                                        scratch_pool);
          notify_func(notify_baton, notify, scratch_pool);
        }
    }
  else
    {
      /* Do the next best thing: retry below this path */
      SVN_ERR(crop_children(wc_ctx->db, local_abspath, depth, svn_depth_empty,
                            notify_func, notify_baton,
                            cancel_func, cancel_baton,
                            scratch_pool));
    }

return SVN_NO_ERROR;
}

svn_error_t *
svn_wc_crop_tree2(svn_wc_context_t *wc_ctx,
                  const char *local_abspath,
                  svn_depth_t depth,
                  svn_cancel_func_t cancel_func,
                  void *cancel_baton,
                  svn_wc_notify_func2_t notify_func,
                  void *notify_baton,
                  apr_pool_t *scratch_pool)
{
  svn_wc__db_t *db = wc_ctx->db;
  svn_wc__db_status_t status;
  svn_node_kind_t kind;
  svn_depth_t dir_depth;

/* Only makes sense when the depth is restrictive. */
  if (depth == svn_depth_infinity)
    return SVN_NO_ERROR; /* Nothing to crop */
  if (!(depth >= svn_depth_empty && depth < svn_depth_infinity))
    return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
      _("Can only crop a working copy with a restrictive depth"));

SVN_ERR(svn_wc__db_read_info(&status, &kind, NULL, NULL, NULL, NULL, NULL,
                               NULL, NULL, &dir_depth, NULL, NULL, NULL, NULL,
                               NULL, NULL, NULL, NULL, NULL, NULL, NULL,
                               NULL, NULL, NULL, NULL, NULL, NULL,
                               db, local_abspath,
                               scratch_pool, scratch_pool));

if (kind != svn_node_dir)
    return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
      _("Can only crop directories"));

switch (status)
    {
      case svn_wc__db_status_not_present:
      case svn_wc__db_status_server_excluded:
        return svn_error_createf(SVN_ERR_WC_PATH_NOT_FOUND, NULL,
                                 _("The node '%s' was not found."),
                                 svn_dirent_local_style(local_abspath,
                                                        scratch_pool));

case svn_wc__db_status_deleted:
        return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
                               _("Cannot crop '%s': it is going to be removed "
                                 "from repository. Try commit instead"),
                               svn_dirent_local_style(local_abspath,
                                                      scratch_pool));

case svn_wc__db_status_added:
        return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
                                 _("Cannot crop '%s': it is to be added "
                                   "to the repository. Try commit instead"),
                                 svn_dirent_local_style(local_abspath,
                                                        scratch_pool));
      case svn_wc__db_status_excluded:
        return SVN_NO_ERROR; /* Nothing to do */

case svn_wc__db_status_normal:
      case svn_wc__db_status_incomplete:
        break;

default:
        SVN_ERR_MALFUNCTION();
    }

SVN_ERR(crop_children(db, local_abspath, dir_depth, depth,
                        notify_func, notify_baton,
                        cancel_func, cancel_baton, scratch_pool));

return svn_error_trace(svn_wc__wq_run(db, local_abspath,
                                        cancel_func, cancel_baton,
                                        scratch_pool));
}

003 File Manager

Editing: crop.c

Upload File

Create Folder