subversion/bindings/swig/include/svn_containers.swg

   1 /*
   2  * ====================================================================
   3  * Copyright (c) 2000-2007 CollabNet.  All rights reserved.
   4  *
   5  * This software is licensed as described in the file COPYING, which
   6  * you should have received as part of this distribution.  The terms
   7  * are also available at http://subversion.tigris.org/license-1.html.
   8  * If newer versions of this license are posted there, you may use a
   9  * newer version instead, at your option.
  10  *
  11  * This software consists of voluntary contributions made by many
  12  * individuals.  For exact contribution history, see the revision
  13  * history and logs, available at http://subversion.tigris.org/.
  14  * ====================================================================
  15  *
  16  * svn_containers.swg: This is a child file of svn_types.swg, and
  17  *   should not be included directly.  This file contains typemaps
  18  *   that deal with "container" data types (e.g. apr_hash_t,
  19  *   apr_array_header_t, etc.).
  20  */
  21
  22 /* =======================================================================
  23    %typemap(argout) apr_hash_t **
  24 */
  25
  26 #ifdef SWIGPYTHON
  27 %define %hash_argout_typemap(ParamName, ValueType)
  28 %typemap(argout) apr_hash_t **ParamName {
  29   %append_output(svn_swig_py_convert_hash(*$1,
  30                                           $descriptor(ValueType),
  31                                           _global_py_pool));
  32 }
  33 %enddef
  34 #endif
  35 #ifdef SWIGPERL
  36 %define %hash_argout_typemap(ParamName, ValueType)
  37 %typemap(argout) apr_hash_t **ParamName {
  38   %append_output(svn_swig_pl_convert_hash(*$1, $descriptor(ValueType)));
  39 }
  40 %enddef
  41 #endif
  42 #ifdef SWIGRUBY
  43 %define %hash_argout_typemap(ParamName, ValueType)
  44 %typemap(argout) apr_hash_t **ParamName {
  45   %append_output(svn_swig_rb_apr_hash_to_hash_swig_type(*$1,
  46                                                         #ValueType));
  47 }
  48 %enddef
  49 #endif
  50
  51 %hash_argout_typemap(dirents, svn_dirent_t *)
  52 %hash_argout_typemap(locks, svn_lock_t *)
  53 #ifdef SWIGPYTHON
  54 /* FIXME: We are effectively treating this hash as an opaque blob...
  55    this is because we currently do not have suitable typemaps to convert
  56    it back to an apr_hash_t * for use. */
  57 %typemap(argout) apr_hash_t **cfg_hash {
  58   %append_output(svn_swig_NewPointerObj(*$1, $descriptor(apr_hash_t *),
  59                                         _global_py_pool, args));
  60 }
  61 #else
  62 %hash_argout_typemap(cfg_hash, svn_config_t *)
  63 #endif
  64
  65 /* -----------------------------------------------------------------------
  66    Output of apr_hash_t * <const char *, svn_string_t *>
  67    (commonly used for property name and value pairs)
  68 */
  69
  70 #ifdef SWIGPYTHON
  71 %typemap(argout) apr_hash_t **HASH_SVN_STRING {
  72   %append_output(svn_swig_py_prophash_to_dict(*$1));
  73 }
  74 %typemap(argout) apr_hash_t **HASH_SVN_STRING_MAYBENULL {
  75   %append_output(!*$1 ? Py_None : svn_swig_py_prophash_to_dict(*$1));
  76 }
  77 #endif
  78 #ifdef SWIGPERL
  79 %typemap(argout) apr_hash_t **HASH_SVN_STRING {
  80   %append_output(svn_swig_pl_prophash_to_hash(*$1));
  81 }
  82 %typemap(argout) apr_hash_t **HASH_SVN_STRING_MAYBENULL {
  83   %append_output(!*$1 ? &PL_sv_undef : svn_swig_pl_prophash_to_hash(*$1));
  84 }
  85 #endif
  86 #ifdef SWIGRUBY
  87 %typemap(argout) apr_hash_t **HASH_SVN_STRING {
  88   %append_output(svn_swig_rb_apr_hash_to_hash_svn_string(*$1));
  89 }
  90 %typemap(argout) apr_hash_t **HASH_SVN_STRING_MAYBENULL {
  91   %append_output(!*$1 ? Qnil : svn_swig_rb_apr_hash_to_hash_svn_string(*$1));
  92 }
  93 #endif
  94 %apply apr_hash_t **HASH_SVN_STRING {
  95   apr_hash_t **props,
  96   apr_hash_t **original_props,
  97   apr_hash_t **table_p
  98 };
  99 %apply apr_hash_t **HASH_SVN_STRING_MAYBENULL {
 100   /* svn_config_read_auth_data() */
 101   apr_hash_t **hash
 102 };
 103
 104
 105 /* -----------------------------------------------------------------------
 106    Output of apr_hash_t * <const char *, const char *>
 107 */
 108
 109 #ifdef SWIGRUBY
 110 %typemap(argout) apr_hash_t **HASH_CSTRING {
 111   %append_output(svn_swig_rb_apr_hash_to_hash_string(*$1));
 112 }
 113 #endif
 114
 115
 116 /* -----------------------------------------------------------------------
 117    apr_hash_t **locations
 118    svn_repos_trace_node_locations()
 119    svn_ra_get_locations()
 120 */
 121
 122 #ifdef SWIGPYTHON
 123 %typemap(argout) apr_hash_t **locations {
 124   %append_output(svn_swig_py_locationhash_to_dict(*$1));
 125 }
 126 #endif
 127 #ifdef SWIGRUBY
 128 %typemap(argout) apr_hash_t **locations
 129 {
 130   %append_output(svn_swig_rb_apr_revnum_key_hash_to_hash_string(*$1));
 131 }
 132 #endif
 133
 134 /* -----------------------------------------------------------------------
 135    apr_hash_t **externals_old
 136    apr_hash_t **externals_new
 137    svn_wc_edited_externals()
 138 */
 139
 140 #ifdef SWIGRUBY
 141 %typemap(argout) apr_hash_t **externals_old, apr_hash_t **externals_new {
 142   %append_output(svn_swig_rb_apr_hash_to_hash_string(*$1));
 143 }
 144 #endif
 145
 146
 147 /* =======================================================================
 148    %typemap(in) apr_hash_t *
 149 */
 150
 151 /* -----------------------------------------------------------------------
 152    Input of apr_hash_t * <const char *, svn_string_t *>
 153    (commonly used for property name and value pairs)
 154 */
 155
 156 #ifdef SWIGPYTHON
 157 %typemap(in) apr_hash_t *PROPHASH
 158   (apr_pool_t *_global_pool = NULL, PyObject *_global_py_pool = NULL)
 159 {
 160   if (_global_pool == NULL)
 161   {
 162     if (svn_swig_py_get_parent_pool(args, $descriptor(apr_pool_t *),
 163                                     &_global_py_pool, &_global_pool))
 164       SWIG_fail;
 165   }
 166
 167   $1 = svn_swig_py_prophash_from_dict($input, _global_pool);
 168   if (PyErr_Occurred()) {
 169     SWIG_fail;
 170   }
 171 }
 172
 173 %typemap(out) apr_hash_t *PROPHASH
 174 {
 175   %append_output(svn_swig_py_prophash_to_dict($1));
 176 }
 177 #endif
 178
 179 #ifdef SWIGPYTHON
 180 %typemap(in) apr_hash_t *changed_paths
 181   (apr_pool_t *_global_pool = NULL, PyObject *_global_py_pool = NULL)
 182 {
 183   if (_global_pool == NULL)
 184   {
 185     if (svn_swig_py_get_parent_pool(args, $descriptor(apr_pool_t *),
 186                                     &_global_py_pool, &_global_pool))
 187       SWIG_fail;
 188   }
 189
 190   $1 = svn_swig_py_changed_path_hash_from_dict($input, _global_pool);
 191   if (PyErr_Occurred()) {
 192     SWIG_fail;
 193   }
 194 }
 195 %typemap(out) apr_hash_t *changed_paths
 196 {
 197   %append_output(svn_swig_py_changed_path_hash_to_dict($1));
 198 }
 199 #endif
 200
 201 #ifdef SWIGRUBY
 202 %typemap(in) apr_hash_t *PROPHASH
 203 {
 204   VALUE rb_pool = Qnil;
 205   if (!_global_pool) {
 206     svn_swig_rb_get_pool(argc, argv, self, &rb_pool, &_global_pool);
 207     svn_swig_rb_push_pool(rb_pool);
 208   }
 209   $1 = svn_swig_rb_hash_to_apr_hash_svn_string($input, _global_pool);
 210   _global_pool = NULL;
 211   if (!NIL_P(rb_pool)) {
 212     if (NIL_P($1)) {
 213       svn_swig_rb_destroy_pool(rb_pool);
 214     } else {
 215       svn_swig_rb_set_pool_for_no_swig_type($input, rb_pool);
 216     }
 217     svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 218   }
 219 }
 220 #endif
 221
 222 #if defined(SWIGPYTHON) || defined(SWIGRUBY)
 223 %apply apr_hash_t *PROPHASH {
 224   apr_hash_t *target_props,
 225   apr_hash_t *source_props,
 226   apr_hash_t *hash,
 227   apr_hash_t *props,
 228   apr_hash_t *revprop_table,
 229   apr_hash_t *revprops
 230 };
 231 #endif
 232
 233 /* -----------------------------------------------------------------------
 234    Input of scripting hash/dictionary (string => string)
 235    converted to apr_hash_t (const char * => const char *)
 236 */
 237 #ifdef SWIGPYTHON
 238 %typemap(in) apr_hash_t *HASH_CSTRING {
 239   $1 = svn_swig_py_stringhash_from_dict($input, _global_pool);
 240 }
 241 %typemap(in) apr_hash_t *HASH_CSTRING_MAYBENULL {
 242   /* PYTHON-FIXME: Handle None -> NULL. */
 243   $1 = svn_swig_py_stringhash_from_dict($input, _global_pool);
 244 }
 245 #endif
 246 #ifdef SWIGPERL
 247 %typemap(in) apr_hash_t *HASH_CSTRING {
 248   $1 = svn_swig_pl_strings_to_hash($input, _global_pool);
 249 }
 250 %typemap(in) apr_hash_t *HASH_CSTRING_MAYBENULL {
 251   /* PERL-FIXME: Handle undef -> NULL. */
 252   $1 = svn_swig_pl_strings_to_hash($input, _global_pool);
 253 }
 254 #endif
 255 #ifdef SWIGRUBY
 256 %typemap(in) apr_hash_t *HASH_CSTRING {
 257   $1 = svn_swig_rb_hash_to_apr_hash_string($input, _global_pool);
 258 }
 259 %typemap(in) apr_hash_t *HASH_CSTRING_MAYBENULL {
 260   VALUE rb_pool = Qnil;
 261   if (!_global_pool) {
 262     svn_swig_rb_get_pool(argc, argv, self, &rb_pool, &_global_pool);
 263     svn_swig_rb_push_pool(rb_pool);
 264   }
 265   $1 = (NIL_P($input)) ? NULL :
 266     svn_swig_rb_hash_to_apr_hash_string($input, _global_pool);
 267   _global_pool = NULL;
 268   if (!NIL_P(rb_pool)) {
 269     if (NIL_P($1)) {
 270       svn_swig_rb_destroy_pool(rb_pool);
 271     } else {
 272       svn_swig_rb_set_pool_for_no_swig_type($input, rb_pool);
 273     }
 274     svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
 275   }
 276 }
 277
 278 %typemap(out) apr_hash_t *HASH_CSTRING_MAYBENULL {
 279   $result = $1 ? svn_swig_rb_apr_hash_to_hash_string($1) : Qnil;
 280 }
 281 #endif
 282
 283 %apply apr_hash_t *HASH_CSTRING {
 284   apr_hash_t *path_tokens
 285 };
 286 %apply apr_hash_t *HASH_CSTRING_MAYBENULL {
 287   apr_hash_t *fs_config,
 288   apr_hash_t *lock_tokens
 289 };
 290
 291 /* -----------------------------------------------------------------------
 292    handle config and fs_config in svn_{fs,repos}_create
 293 */
 294
 295 #ifdef SWIGPERL
 296 %typemap(in) apr_hash_t *config {
 297     $1 = svn_swig_pl_objs_to_hash_by_name ($input, "svn_config_t *",
 298                                            _global_pool);
 299 }
 300 #endif
 301 #ifdef SWIGRUBY
 302 %typemap(in) apr_hash_t *config
 303 {
 304   if (NIL_P($input)) {
 305     $1 = NULL;
 306   } else {
 307     $1 = svn_swig_rb_hash_to_apr_hash_swig_type($input, "svn_config_t *", _global_pool);
 308   }
 309 }
 310 #endif
 311
 312 #ifdef SWIGRUBY
 313 %typemap(in) apr_hash_t *path_revs
 314 {
 315   $1 = svn_swig_rb_hash_to_apr_hash_revnum($input, _global_pool);
 316 }
 317 #endif
 318
 319 #ifdef SWIGPYTHON
 320 %typemap(in) apr_hash_t *path_revs
 321 {
 322   $1 = svn_swig_py_path_revs_hash_from_dict($input, _global_pool);
 323 }
 324 #endif
 325
 326 /* =======================================================================
 327    %typemap(argout) apr_array_header_t **
 328 */
 329
 330 /* -----------------------------------------------------------------------
 331    Output of apr_array_header_t * <svn_prop_t *>
 332 */
 333 #ifdef SWIGRUBY
 334 %typemap(argout) apr_array_header_t **OUTPUT_OF_PROP {
 335   %append_output(svn_swig_rb_prop_apr_array_to_hash_prop(*$1));
 336 }
 337
 338 %apply apr_array_header_t **OUTPUT_OF_PROP {
 339   apr_array_header_t **entry_props,
 340   apr_array_header_t **wc_props,
 341   apr_array_header_t **regular_props,
 342   apr_array_header_t **propdiffs
 343 };
 344 #endif
 345
 346 #ifdef SWIGPYTHON
 347 %typemap(argout) apr_array_header_t **OUTPUT_OF_PROP {
 348   %append_output(svn_swig_py_proparray_to_dict(*$1));
 349 }
 350 #endif
 351
 352 /* -----------------------------------------------------------------------
 353    Output of apr_array_header_t * <const char *>
 354 */
 355
 356 #ifdef SWIGPYTHON
 357 %typemap(argout) apr_array_header_t **OUTPUT_OF_CONST_CHAR_P {
 358   %append_output(svn_swig_py_array_to_list(*$1));
 359 }
 360 #endif
 361 #ifdef SWIGPERL
 362 %typemap(argout) apr_array_header_t **OUTPUT_OF_CONST_CHAR_P {
 363   %append_output(svn_swig_pl_array_to_list(*$1));
 364 }
 365 #endif
 366 #ifdef SWIGRUBY
 367 %typemap(argout) apr_array_header_t **OUTPUT_OF_CONST_CHAR_P {
 368   %append_output(svn_swig_rb_apr_array_to_array_string(*$1));
 369 }
 370 #endif
 371
 372 %apply apr_array_header_t **OUTPUT_OF_CONST_CHAR_P {
 373   apr_array_header_t **patterns,
 374   apr_array_header_t **logfiles,
 375   apr_array_header_t **names_p
 376 };
 377
 378 /* -----------------------------------------------------------------------
 379    apr_array_header_t **externals_p
 380    svn_wc_parse_externals_description3()
 381 */
 382
 383 #ifdef SWIGRUBY
 384 %typemap(argout) apr_array_header_t **externals_p {
 385   %append_output(svn_swig_rb_apr_array_to_array_external_item2(*$1));
 386 }
 387 #endif
 388
 389 /* svn_client_update3/svn_client_update2 */
 390 #ifdef SWIGPYTHON
 391 %typemap(argout) apr_array_header_t **result_revs {
 392   %append_output(svn_swig_py_revarray_to_list(*$1));
 393   if (PyErr_Occurred()) {
 394     SWIG_fail;
 395   }
 396 }
 397 #endif
 398
 399 #ifdef SWIGRUBY
 400 %typemap(argout) apr_array_header_t **result_revs {
 401   %append_output(svn_swig_rb_apr_array_to_array_svn_rev(*$1));
 402 }
 403 #endif
 404
 405 /* =======================================================================
 406    %typemap(in) apr_array_header_t *
 407 */
 408
 409 /* -----------------------------------------------------------------------
 410    apr_array_header_t *location_revisions
 411    svn_repos_trace_node_locations()
 412    svn_ra_get_locations()
 413 */
 414
 415 #ifdef SWIGPYTHON
 416 %typemap(in) apr_array_header_t *location_revisions {
 417     $1 = (apr_array_header_t *) svn_swig_py_revnums_to_array($input,
 418                                                              _global_pool);
 419     if ($1 == NULL)
 420         SWIG_fail;
 421 }
 422 #endif
 423 #ifdef SWIGRUBY
 424 %typemap(in) apr_array_header_t *location_revisions {
 425   $1 = svn_swig_rb_array_to_apr_array_revnum($input, _global_pool);
 426 }
 427 #endif
 428
 429 /* -----------------------------------------------------------------------
 430    define a general INPUT param of an array of const char * items.
 431  */
 432
 433 #ifdef SWIGPYTHON
 434 %typemap(in) const apr_array_header_t *STRINGLIST {
 435     $1 = (apr_array_header_t *) svn_swig_py_strings_to_array($input,
 436                                                              _global_pool);
 437     if (PyErr_Occurred())
 438       SWIG_fail;
 439 }
 440 %typemap(in) const apr_array_header_t *STRINGLIST_MAY_BE_NULL {
 441     $1 = ($input == Py_None)
 442            ? NULL
 443            : (apr_array_header_t *)svn_swig_py_strings_to_array($input,
 444                                                                 _global_pool);
 445     if (PyErr_Occurred())
 446       SWIG_fail;
 447 }
 448 #endif
 449 #ifdef SWIGPERL
 450 %typemap(in) const apr_array_header_t *STRINGLIST {
 451     $1 = (apr_array_header_t *) svn_swig_pl_strings_to_array($input,
 452                                                              _global_pool);
 453 }
 454 #endif
 455 #ifdef SWIGRUBY
 456 %typemap(in) const apr_array_header_t *STRINGLIST {
 457   $1 = svn_swig_rb_strings_to_apr_array($input, _global_pool);
 458 }
 459 %typemap(in) const apr_array_header_t *STRINGLIST_MAY_BE_NULL {
 460   $1 = (NIL_P($input)) ? NULL :
 461     svn_swig_rb_strings_to_apr_array($input, _global_pool);
 462 }
 463 #endif
 464
 465 /* svn_delta_path_driver() mutates its 'paths' argument (by sorting it),
 466    despite the fact that it is notionally an input parameter - hence, the
 467    lack of 'const' in that one case.
 468
 469    svn_wc_get_update_editor3() and svn_wc_get_switch_editor3() aren't changing
 470    their 'preserved_exts' argument, but it is forwarded to
 471    svn_cstring_match_glob_list which also doesn't modify it, but does not have
 472    const in its prototype.  */
 473 %apply const apr_array_header_t *STRINGLIST {
 474   const apr_array_header_t *args,
 475   const apr_array_header_t *diff_options,
 476   apr_array_header_t *paths,
 477   apr_array_header_t *revprops,
 478   const apr_array_header_t *targets,
 479   apr_array_header_t *preserved_exts
 480 };
 481
 482 /* -----------------------------------------------------------------------
 483    auth provider convertors
 484 */
 485 #ifdef SWIGPERL
 486 %typemap(in) apr_array_header_t *providers {
 487     $1 = (apr_array_header_t *) svn_swig_pl_objs_to_array($input,
 488       $descriptor(svn_auth_provider_object_t *), _global_pool);
 489 }
 490 #endif
 491
 492 #ifdef SWIGPYTHON
 493 %typemap(in) apr_array_header_t *providers {
 494     svn_auth_provider_object_t *provider;
 495     int targlen;
 496     if (!PySequence_Check($input)) {
 497         PyErr_SetString(PyExc_TypeError, "not a sequence");
 498         SWIG_fail;
 499     }
 500     targlen = PySequence_Length($input);
 501     $1 = apr_array_make(_global_pool, targlen, sizeof(provider));
 502     ($1)->nelts = targlen;
 503     while (targlen--) {
 504         provider = svn_swig_MustGetPtr(PySequence_GetItem($input, targlen),
 505           $descriptor(svn_auth_provider_object_t *), $svn_argnum);
 506         if (PyErr_Occurred()) {
 507           SWIG_fail;
 508         }
 509         APR_ARRAY_IDX($1, targlen, svn_auth_provider_object_t *) = provider;
 510     }
 511 }
 512 #endif
 513
 514 #ifdef SWIGRUBY
 515 %typemap(in) apr_array_header_t *providers
 516 {
 517   $1 = svn_swig_rb_array_to_auth_provider_object_apr_array($input, _global_pool);
 518 }
 519 #endif
 520
 521 /* -----------------------------------------------------------------------
 522    An array of svn_prop_t.
 523 */
 524
 525 #ifdef SWIGRUBY
 526 %typemap(in) apr_array_header_t *ROW_PROP_LIST
 527 {
 528   $1 = svn_swig_rb_to_apr_array_row_prop($input, _global_pool);
 529 }
 530
 531 %apply apr_array_header_t *ROW_PROP_LIST {
 532   apr_array_header_t *proplist
 533 };
 534 #endif
 535
 536 /* -----------------------------------------------------------------------
 537    An array of svn_prop_t *.
 538 */
 539
 540 #ifdef SWIGRUBY
 541 %typemap(in) apr_array_header_t *PROP_LIST
 542 {
 543   VALUE rb_pool;
 544   apr_pool_t *pool;
 545
 546   svn_swig_rb_get_pool(argc, argv, self, &rb_pool, &pool);
 547
 548   $1 = svn_swig_rb_to_apr_array_prop($input, pool);
 549 }
 550
 551 %typemap(out) apr_array_header_t *PROP_LIST
 552 {
 553   %append_output(svn_swig_rb_prop_apr_array_to_hash_prop($1));
 554 }
 555
 556 %typemap(in) apr_array_header_t *PROP_LIST_MAY_BE_NULL
 557 {
 558   if (NIL_P($input)) {
 559     $1 = NULL;
 560   } else {
 561     VALUE rb_pool;
 562     apr_pool_t *pool;
 563
 564     svn_swig_rb_get_pool(argc, argv, self, &rb_pool, &pool);
 565     $1 = svn_swig_rb_to_apr_array_prop($input, pool);
 566   }
 567 }
 568
 569 %typemap(out) apr_array_header_t *PROP_LIST_MAY_BE_NULL
 570 {
 571   %append_output($1 ? svn_swig_rb_prop_apr_array_to_hash_prop($1) : Qnil);
 572 }
 573
 574 %apply apr_array_header_t *PROP_LIST {
 575   apr_array_header_t *wcprop_changes,
 576   apr_array_header_t *propchanges
 577 };
 578
 579 %apply apr_array_header_t *PROP_LIST_MAY_BE_NULL {
 580   apr_array_header_t *incoming_prop_changes,
 581   apr_array_header_t *outgoing_prop_changes,
 582   apr_array_header_t *merge_options
 583 };
 584
 585 #endif
 586
 587 /* -----------------------------------------------------------------------
 588    Input of apr_array_header_t * <svn_merge_range_t *>
 589 */
 590 #ifdef SWIGPYTHON
 591 %typemap(in) apr_array_header_t *RANGELIST {
 592   $1 = svn_swig_py_rangelist_to_array($input, _global_pool);
 593   if (PyErr_Occurred()) {
 594     SWIG_fail;
 595   }
 596 }
 597 #endif
 598
 599 #ifdef SWIGRUBY
 600 %typemap(in) apr_array_header_t *RANGELIST {
 601   $1 = svn_swig_rb_array_to_apr_array_merge_range($input, _global_pool);
 602 }
 603 #endif
 604
 605 /* -----------------------------------------------------------------------
 606    Input of apr_array_header_t * <svn_client_copy_source_t *>
 607 */
 608 #ifdef SWIGRUBY
 609 %typemap(in) apr_array_header_t *SOURCES {
 610   $1 = svn_swig_rb_array_to_apr_array_copy_source($input, _global_pool);
 611 }
 612 #endif
 613
 614 /* -----------------------------------------------------------------------
 615    Input of apr_array_header_t * <svn_opt_revision_range_t *>
 616 */
 617 #ifdef SWIGRUBY
 618 %typemap(in) apr_array_header_t *REVISION_RANGE_LIST {
 619   $1 = svn_swig_rb_array_to_apr_array_revision_range($input, _global_pool);
 620 }
 621 #endif
 622
 623 /* -----------------------------------------------------------------------
 624    Input of
 625    apr_hash_t * <const char *, apr_array_header_t * <svn_merge_range_t *>>
 626 */
 627 #ifdef SWIGPYTHON
 628 %typemap(in) apr_hash_t *MERGEINFO {
 629   $1 = svn_swig_py_mergeinfo_from_dict($input, _global_pool);
 630   if (PyErr_Occurred()) {
 631     SWIG_fail;
 632   }
 633 }
 634 #endif
 635
 636 #ifdef SWIGRUBY
 637 %typemap(in) apr_hash_t *MERGEINFO {
 638   $1 = svn_swig_rb_hash_to_apr_hash_merge_range($input, _global_pool);
 639 }
 640 #endif
 641
 642 /* -----------------------------------------------------------------------
 643    Output of
 644    apr_hash_t * <const char *, apr_array_header_t * <svn_merge_range_t *>>
 645 */
 646 #ifdef SWIGPYTHON
 647 %typemap(argout) apr_hash_t **MERGEINFO
 648 {
 649   %append_output
 650     (svn_swig_py_mergeinfo_to_dict(*$1, $descriptor(svn_merge_range_t *),
 651                                     _global_py_pool));
 652
 653   if (PyErr_Occurred()) {
 654     SWIG_fail;
 655   }
 656 }
 657
 658 %typemap(in) apr_hash_t **MERGEINFO_INOUT ($*1_ltype temp)
 659 {
 660   $1 = &temp;
 661   *$1 = svn_swig_py_mergeinfo_from_dict($input, _global_pool);
 662   if (PyErr_Occurred()) {
 663     SWIG_fail;
 664   }
 665 }
 666 #endif
 667
 668 #ifdef SWIGRUBY
 669 %typemap(argout) apr_hash_t **MERGEINFO
 670 {
 671   %append_output(svn_swig_rb_apr_hash_to_hash_merge_range(*$1));
 672 }
 673
 674 %typemap(in) apr_hash_t **MERGEINFO_INOUT ($*1_ltype temp)
 675 {
 676   $1 = &temp;
 677   *$1 = svn_swig_rb_hash_to_apr_hash_merge_range($input, _global_pool);
 678 }
 679 #endif
 680
 681 #if defined(SWIGPYTHON) || defined(SWIGRUBY)
 682 %typemap(argout) apr_hash_t **MERGEINFO_INOUT = apr_hash_t **MERGEINFO;
 683 #endif
 684
 685 /* -----------------------------------------------------------------------
 686    Output of
 687    apr_hash_t * <const char *,
 688                  apr_hash_t * <const char *,
 689                                array_header_t * <svn_merge_range_t *>>>
 690 */
 691 #ifdef SWIGRUBY
 692 %typemap(argout) apr_hash_t **MERGEINFO_HASH
 693 {
 694   %append_output(svn_swig_rb_apr_hash_to_hash_merge_range_hash(*$1));
 695 }
 696 #endif
 697
 698 /* -----------------------------------------------------------------------
 699    Output of apr_array_header_t * <svn_merge_range_t *>
 700 */
 701 #ifdef SWIGPYTHON
 702 %typemap(argout) apr_array_header_t **RANGELIST {
 703   %append_output
 704     (svn_swig_py_rangelist_to_list(*$1, $descriptor(svn_merge_range_t *),
 705                                    _global_py_pool));
 706   if (PyErr_Occurred()) {
 707     SWIG_fail;
 708   }
 709 }
 710
 711 %typemap(in) apr_array_header_t **RANGELIST_INOUT ($*1_ltype temp)
 712 {
 713   $1 = &temp;
 714   *$1 = svn_swig_py_rangelist_to_array($input, _global_pool);
 715   if (PyErr_Occurred()) {
 716     SWIG_fail;
 717   }
 718 }
 719 #endif
 720
 721 #ifdef SWIGRUBY
 722 %typemap(argout) apr_array_header_t **RANGELIST {
 723   %append_output(svn_swig_rb_apr_array_to_array_merge_range(*$1));
 724 }
 725
 726 %typemap(in) apr_array_header_t **RANGELIST_INOUT ($*1_ltype temp)
 727 {
 728   $1 = &temp;
 729   *$1 = svn_swig_rb_array_to_apr_array_merge_range($input, _global_pool);
 730 }
 731 #endif
 732
 733 #if defined(SWIGPYTHON) || defined(SWIGRUBY)
 734 %typemap(argout) apr_array_header_t **RANGELIST_INOUT =
 735    apr_array_header_t **RANGELIST;
 736 #endif