subversion/libsvn_delta/cancel.c

   1 /*
   2  * cancel.c:  Routines to support cancellation of running subversion functions.
   3  *
   4  * ====================================================================
   5  * Copyright (c) 2000-2006 CollabNet.  All rights reserved.
   6  *
   7  * This software is licensed as described in the file COPYING, which
   8  * you should have received as part of this distribution.  The terms
   9  * are also available at http://subversion.tigris.org/license-1.html.
  10  * If newer versions of this license are posted there, you may use a
  11  * newer version instead, at your option.
  12  *
  13  * This software consists of voluntary contributions made by many
  14  * individuals.  For exact contribution history, see the revision
  15  * history and logs, available at http://subversion.tigris.org/.
  16  * ====================================================================
  17  */
  18
  19 #include "svn_delta.h"
  20
  21 struct edit_baton
  22 {
  23   const svn_delta_editor_t *wrapped_editor;
  24   void *wrapped_edit_baton;
  25
  26   svn_cancel_func_t cancel_func;
  27   void *cancel_baton;
  28 };
  29
  30 struct dir_baton
  31 {
  32   void *edit_baton;
  33   void *wrapped_dir_baton;
  34 };
  35
  36 struct file_baton
  37 {
  38   void *edit_baton;
  39   void *wrapped_file_baton;
  40 };
  41
  42 static svn_error_t *
  43 set_target_revision(void *edit_baton,
  44                     svn_revnum_t target_revision,
  45                     apr_pool_t *pool)
  46 {
  47   struct edit_baton *eb = edit_baton;
  48
  49   SVN_ERR(eb->cancel_func(eb->cancel_baton));
  50
  51   SVN_ERR(eb->wrapped_editor->set_target_revision(eb->wrapped_edit_baton,
  52                                                   target_revision,
  53                                                   pool));
  54
  55   return SVN_NO_ERROR;
  56 }
  57
  58 static svn_error_t *
  59 open_root(void *edit_baton,
  60           svn_revnum_t base_revision,
  61           apr_pool_t *pool,
  62           void **root_baton)
  63 {
  64   struct edit_baton *eb = edit_baton;
  65   struct dir_baton *dir_baton = apr_palloc(pool, sizeof(*dir_baton));
  66
  67   SVN_ERR(eb->cancel_func(eb->cancel_baton));
  68
  69   SVN_ERR(eb->wrapped_editor->open_root(eb->wrapped_edit_baton,
  70                                         base_revision,
  71                                         pool,
  72                                         &dir_baton->wrapped_dir_baton));
  73
  74   dir_baton->edit_baton = edit_baton;
  75
  76   *root_baton = dir_baton;
  77
  78   return SVN_NO_ERROR;
  79 }
  80
  81 static svn_error_t *
  82 delete_entry(const char *path,
  83              svn_revnum_t base_revision,
  84              void *parent_baton,
  85              apr_pool_t *pool)
  86 {
  87   struct dir_baton *pb = parent_baton;
  88   struct edit_baton *eb = pb->edit_baton;
  89
  90   SVN_ERR(eb->cancel_func(eb->cancel_baton));
  91
  92   SVN_ERR(eb->wrapped_editor->delete_entry(path,
  93                                            base_revision,
  94                                            pb->wrapped_dir_baton,
  95                                            pool));
  96
  97   return SVN_NO_ERROR;
  98 }
  99
 100 static svn_error_t *
 101 add_directory(const char *path,
 102               void *parent_baton,
 103               const char *copyfrom_path,
 104               svn_revnum_t copyfrom_revision,
 105               apr_pool_t *pool,
 106               void **child_baton)
 107 {
 108   struct dir_baton *pb = parent_baton;
 109   struct edit_baton *eb = pb->edit_baton;
 110   struct dir_baton *b = apr_palloc(pool, sizeof(*b));
 111
 112   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 113
 114   SVN_ERR(eb->wrapped_editor->add_directory(path,
 115                                             pb->wrapped_dir_baton,
 116                                             copyfrom_path,
 117                                             copyfrom_revision,
 118                                             pool,
 119                                             &b->wrapped_dir_baton));
 120
 121   b->edit_baton = eb;
 122   *child_baton = b;
 123
 124   return SVN_NO_ERROR;
 125 }
 126
 127 static svn_error_t *
 128 open_directory(const char *path,
 129                void *parent_baton,
 130                svn_revnum_t base_revision,
 131                apr_pool_t *pool,
 132                void **child_baton)
 133 {
 134   struct dir_baton *pb = parent_baton;
 135   struct edit_baton *eb = pb->edit_baton;
 136   struct dir_baton *db = apr_palloc(pool, sizeof(*db));
 137
 138   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 139
 140   SVN_ERR(eb->wrapped_editor->open_directory(path,
 141                                              pb->wrapped_dir_baton,
 142                                              base_revision,
 143                                              pool,
 144                                              &db->wrapped_dir_baton));
 145
 146   db->edit_baton = eb;
 147   *child_baton = db;
 148
 149   return SVN_NO_ERROR;
 150 }
 151
 152 static svn_error_t *
 153 add_file(const char *path,
 154          void *parent_baton,
 155          const char *copyfrom_path,
 156          svn_revnum_t copyfrom_revision,
 157          apr_pool_t *pool,
 158          void **file_baton)
 159 {
 160   struct dir_baton *pb = parent_baton;
 161   struct edit_baton *eb = pb->edit_baton;
 162   struct file_baton *fb = apr_palloc(pool, sizeof(*fb));
 163
 164   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 165
 166   SVN_ERR(eb->wrapped_editor->add_file(path,
 167                                        pb->wrapped_dir_baton,
 168                                        copyfrom_path,
 169                                        copyfrom_revision,
 170                                        pool,
 171                                        &fb->wrapped_file_baton));
 172
 173   fb->edit_baton = eb;
 174   *file_baton = fb;
 175
 176   return SVN_NO_ERROR;
 177 }
 178
 179 static svn_error_t *
 180 open_file(const char *path,
 181           void *parent_baton,
 182           svn_revnum_t base_revision,
 183           apr_pool_t *pool,
 184           void **file_baton)
 185 {
 186   struct dir_baton *pb = parent_baton;
 187   struct edit_baton *eb = pb->edit_baton;
 188   struct file_baton *fb = apr_palloc(pool, sizeof(*fb));
 189
 190   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 191
 192   SVN_ERR(eb->wrapped_editor->open_file(path,
 193                                         pb->wrapped_dir_baton,
 194                                         base_revision,
 195                                         pool,
 196                                         &fb->wrapped_file_baton));
 197
 198   fb->edit_baton = eb;
 199   *file_baton = fb;
 200
 201   return SVN_NO_ERROR;
 202 }
 203
 204 static svn_error_t *
 205 apply_textdelta(void *file_baton,
 206                 const char *base_checksum,
 207                 apr_pool_t *pool,
 208                 svn_txdelta_window_handler_t *handler,
 209                 void **handler_baton)
 210 {
 211   struct file_baton *fb = file_baton;
 212   struct edit_baton *eb = fb->edit_baton;
 213
 214   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 215
 216   SVN_ERR(eb->wrapped_editor->apply_textdelta(fb->wrapped_file_baton,
 217                                               base_checksum,
 218                                               pool,
 219                                               handler,
 220                                               handler_baton));
 221
 222   return SVN_NO_ERROR;
 223 }
 224
 225 static svn_error_t *
 226 close_file(void *file_baton,
 227            const char *text_checksum,
 228            apr_pool_t *pool)
 229 {
 230   struct file_baton *fb = file_baton;
 231   struct edit_baton *eb = fb->edit_baton;
 232
 233   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 234
 235   SVN_ERR(eb->wrapped_editor->close_file(fb->wrapped_file_baton,
 236                                          text_checksum, pool));
 237
 238   return SVN_NO_ERROR;
 239 }
 240
 241 static svn_error_t *
 242 absent_file(const char *path,
 243             void *file_baton,
 244             apr_pool_t *pool)
 245 {
 246   struct file_baton *fb = file_baton;
 247   struct edit_baton *eb = fb->edit_baton;
 248
 249   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 250
 251   SVN_ERR(eb->wrapped_editor->absent_file(path, fb->wrapped_file_baton,
 252                                           pool));
 253
 254   return SVN_NO_ERROR;
 255 }
 256
 257 static svn_error_t *
 258 close_directory(void *dir_baton,
 259                 apr_pool_t *pool)
 260 {
 261   struct dir_baton *db = dir_baton;
 262   struct edit_baton *eb = db->edit_baton;
 263
 264   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 265
 266   SVN_ERR(eb->wrapped_editor->close_directory(db->wrapped_dir_baton,
 267                                               pool));
 268
 269   return SVN_NO_ERROR;
 270 }
 271
 272 static svn_error_t *
 273 absent_directory(const char *path,
 274                  void *dir_baton,
 275                  apr_pool_t *pool)
 276 {
 277   struct dir_baton *db = dir_baton;
 278   struct edit_baton *eb = db->edit_baton;
 279
 280   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 281
 282   SVN_ERR(eb->wrapped_editor->absent_directory(path, db->wrapped_dir_baton,
 283                                                pool));
 284
 285   return SVN_NO_ERROR;
 286 }
 287
 288 static svn_error_t *
 289 change_file_prop(void *file_baton,
 290                  const char *name,
 291                  const svn_string_t *value,
 292                  apr_pool_t *pool)
 293 {
 294   struct file_baton *fb = file_baton;
 295   struct edit_baton *eb = fb->edit_baton;
 296
 297   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 298
 299   SVN_ERR(eb->wrapped_editor->change_file_prop(fb->wrapped_file_baton,
 300                                                name,
 301                                                value,
 302                                                pool));
 303
 304   return SVN_NO_ERROR;
 305 }
 306
 307 static svn_error_t *
 308 change_dir_prop(void *dir_baton,
 309                 const char *name,
 310                 const svn_string_t *value,
 311                 apr_pool_t *pool)
 312 {
 313   struct dir_baton *db = dir_baton;
 314   struct edit_baton *eb = db->edit_baton;
 315
 316   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 317
 318   SVN_ERR(eb->wrapped_editor->change_dir_prop(db->wrapped_dir_baton,
 319                                               name,
 320                                               value,
 321                                               pool));
 322
 323   return SVN_NO_ERROR;
 324 }
 325
 326 static svn_error_t *
 327 close_edit(void *edit_baton,
 328            apr_pool_t *pool)
 329 {
 330   struct edit_baton *eb = edit_baton;
 331
 332   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 333
 334   SVN_ERR(eb->wrapped_editor->close_edit(eb->wrapped_edit_baton, pool));
 335
 336   return SVN_NO_ERROR;
 337 }
 338
 339 static svn_error_t *
 340 abort_edit(void *edit_baton,
 341            apr_pool_t *pool)
 342 {
 343   struct edit_baton *eb = edit_baton;
 344
 345   SVN_ERR(eb->cancel_func(eb->cancel_baton));
 346
 347   SVN_ERR(eb->wrapped_editor->abort_edit(eb->wrapped_edit_baton, pool));
 348
 349   return SVN_NO_ERROR;
 350 }
 351
 352 svn_error_t *
 353 svn_delta_get_cancellation_editor(svn_cancel_func_t cancel_func,
 354                                   void *cancel_baton,
 355                                   const svn_delta_editor_t *wrapped_editor,
 356                                   void *wrapped_edit_baton,
 357                                   const svn_delta_editor_t **editor,
 358                                   void **edit_baton,
 359                                   apr_pool_t *pool)
 360 {
 361   if (cancel_func)
 362     {
 363       svn_delta_editor_t *tree_editor = svn_delta_default_editor(pool);
 364       struct edit_baton *eb = apr_palloc(pool, sizeof(*eb));
 365
 366       tree_editor->set_target_revision = set_target_revision;
 367       tree_editor->open_root = open_root;
 368       tree_editor->delete_entry = delete_entry;
 369       tree_editor->add_directory = add_directory;
 370       tree_editor->open_directory = open_directory;
 371       tree_editor->change_dir_prop = change_dir_prop;
 372       tree_editor->close_directory = close_directory;
 373       tree_editor->absent_directory = absent_directory;
 374       tree_editor->add_file = add_file;
 375       tree_editor->open_file = open_file;
 376       tree_editor->apply_textdelta = apply_textdelta;
 377       tree_editor->change_file_prop = change_file_prop;
 378       tree_editor->close_file = close_file;
 379       tree_editor->absent_file = absent_file;
 380       tree_editor->close_edit = close_edit;
 381       tree_editor->abort_edit = abort_edit;
 382
 383       eb->wrapped_editor = wrapped_editor;
 384       eb->wrapped_edit_baton = wrapped_edit_baton;
 385       eb->cancel_func = cancel_func;
 386       eb->cancel_baton = cancel_baton;
 387
 388       *editor = tree_editor;
 389       *edit_baton = eb;
 390     }
 391   else
 392     {
 393       *editor = wrapped_editor;
 394       *edit_baton = wrapped_edit_baton;
 395     }
 396
 397   return SVN_NO_ERROR;
 398 }