~ubuntu-branches/debian/sid/subversion/sid

« back to all changes in this revision

Viewing changes to subversion/bindings/swig/python/svn_fs.c

  • Committer: Package Import Robot
  • Author(s): James McCoy
  • Date: 2015-08-07 21:32:47 UTC
  • mfrom: (0.2.15) (4.1.7 experimental)
  • Revision ID: package-import@ubuntu.com-20150807213247-ozyewtmgsr6tkewl
Tags: 1.9.0-1
* Upload to unstable
* New upstream release.
  + Security fixes
    - CVE-2015-3184: Mixed anonymous/authenticated path-based authz with
      httpd 2.4
    - CVE-2015-3187: svn_repos_trace_node_locations() reveals paths hidden
      by authz
* Add >= 2.7 requirement for python-all-dev Build-Depends, needed to run
  tests.
* Remove Build-Conflicts against ruby-test-unit.  (Closes: #791844)
* Remove patches/apache_module_dependency in favor of expressing the
  dependencies in authz_svn.load/dav_svn.load.
* Build-Depend on apache2-dev (>= 2.4.16) to ensure ap_some_authn_required()
  is available when building mod_authz_svn and Depend on apache2-bin (>=
  2.4.16) for runtime support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
/* ----------------------------------------------------------------------------
2
2
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 2.0.9
4
 
 * 
5
 
 * This file is not intended to be easily readable and contains a number of 
 
3
 * Version 2.0.12
 
4
 *
 
5
 * This file is not intended to be easily readable and contains a number of
6
6
 * coding conventions designed to improve portability and efficiency. Do not make
7
 
 * changes to this file unless you know what you are doing--modify the SWIG 
8
 
 * interface file instead. 
 
7
 * changes to this file unless you know what you are doing--modify the SWIG
 
8
 * interface file instead.
9
9
 * ----------------------------------------------------------------------------- */
10
10
 
11
11
#define SWIGPYTHON
43
43
#ifndef SWIGUNUSED
44
44
# if defined(__GNUC__)
45
45
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
46
 
#     define SWIGUNUSED __attribute__ ((__unused__)) 
 
46
#     define SWIGUNUSED __attribute__ ((__unused__))
47
47
#   else
48
48
#     define SWIGUNUSED
49
49
#   endif
50
50
# elif defined(__ICC)
51
 
#   define SWIGUNUSED __attribute__ ((__unused__)) 
 
51
#   define SWIGUNUSED __attribute__ ((__unused__))
52
52
# else
53
 
#   define SWIGUNUSED 
 
53
#   define SWIGUNUSED
54
54
# endif
55
55
#endif
56
56
 
57
57
#ifndef SWIG_MSC_UNSUPPRESS_4505
58
58
# if defined(_MSC_VER)
59
59
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
60
 
# endif 
 
60
# endif
61
61
#endif
62
62
 
63
63
#ifndef SWIGUNUSEDPARM
64
64
# ifdef __cplusplus
65
65
#   define SWIGUNUSEDPARM(p)
66
66
# else
67
 
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
 
67
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
68
68
# endif
69
69
#endif
70
70
 
107
107
#   define SWIGSTDCALL __stdcall
108
108
# else
109
109
#   define SWIGSTDCALL
110
 
# endif 
 
110
# endif
111
111
#endif
112
112
 
113
113
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
122
122
 
123
123
 
124
124
 
125
 
/* Python.h has to appear first */
126
 
#include <Python.h>
 
125
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
 
126
/* Use debug wrappers with the Python release dll */
 
127
# undef _DEBUG
 
128
# include <Python.h>
 
129
# define _DEBUG
 
130
#else
 
131
# include <Python.h>
 
132
#endif
127
133
 
128
134
/* -----------------------------------------------------------------------------
129
135
 * swigrun.swg
149
155
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
150
156
  creating a static or dynamic library from the SWIG runtime code.
151
157
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
152
 
  
 
158
 
153
159
  But only do this if strictly necessary, ie, if you have problems
154
160
  with your compiler or suchlike.
155
161
*/
175
181
#define SWIG_POINTER_OWN           0x1
176
182
 
177
183
 
178
 
/* 
 
184
/*
179
185
   Flags/methods for returning states.
180
 
   
181
 
   The SWIG conversion methods, as ConvertPtr, return an integer 
 
186
 
 
187
   The SWIG conversion methods, as ConvertPtr, return an integer
182
188
   that tells if the conversion was successful or not. And if not,
183
189
   an error code can be returned (see swigerrors.swg for the codes).
184
 
   
 
190
 
185
191
   Use the following macros/flags to set or process the returning
186
192
   states.
187
 
   
 
193
 
188
194
   In old versions of SWIG, code such as the following was usually written:
189
195
 
190
196
     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
217
223
    } else {
218
224
      // fail code
219
225
    }
220
 
    
 
226
 
221
227
   I.e., now SWIG_ConvertPtr can return new objects and you can
222
228
   identify the case and take care of the deallocation. Of course that
223
229
   also requires SWIG_ConvertPtr to return new result values, such as
224
230
 
225
 
      int SWIG_ConvertPtr(obj, ptr,...) {         
226
 
        if (<obj is ok>) {                             
227
 
          if (<need new object>) {                     
228
 
            *ptr = <ptr to new allocated object>; 
229
 
            return SWIG_NEWOBJ;                
230
 
          } else {                                     
231
 
            *ptr = <ptr to old object>;        
232
 
            return SWIG_OLDOBJ;                
233
 
          }                                    
234
 
        } else {                                       
235
 
          return SWIG_BADOBJ;                  
236
 
        }                                              
 
231
      int SWIG_ConvertPtr(obj, ptr,...) {
 
232
        if (<obj is ok>) {
 
233
          if (<need new object>) {
 
234
            *ptr = <ptr to new allocated object>;
 
235
            return SWIG_NEWOBJ;
 
236
          } else {
 
237
            *ptr = <ptr to old object>;
 
238
            return SWIG_OLDOBJ;
 
239
          }
 
240
        } else {
 
241
          return SWIG_BADOBJ;
 
242
        }
237
243
      }
238
244
 
239
245
   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
247
253
       int fooi(int);
248
254
 
249
255
   and you call
250
 
 
 
256
 
251
257
      food(1)   // cast rank '1'  (1 -> 1.0)
252
258
      fooi(1)   // cast rank '0'
253
259
 
254
260
   just use the SWIG_AddCast()/SWIG_CheckState()
255
261
*/
256
262
 
257
 
#define SWIG_OK                    (0) 
 
263
#define SWIG_OK                    (0)
258
264
#define SWIG_ERROR                 (-1)
259
265
#define SWIG_IsOK(r)               (r >= 0)
260
 
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
 
266
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
261
267
 
262
268
/* The CastRankLimit says how many bits are used for the cast rank */
263
269
#define SWIG_CASTRANKLIMIT         (1 << 8)
288
294
#  endif
289
295
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
290
296
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
291
 
SWIGINTERNINLINE int SWIG_AddCast(int r) { 
 
297
SWIGINTERNINLINE int SWIG_AddCast(int r) {
292
298
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
293
299
}
294
 
SWIGINTERNINLINE int SWIG_CheckState(int r) { 
295
 
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
 
300
SWIGINTERNINLINE int SWIG_CheckState(int r) {
 
301
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
296
302
}
297
303
#else /* no cast-rank mode */
298
 
#  define SWIG_AddCast
 
304
#  define SWIG_AddCast(r) (r)
299
305
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
300
306
#endif
301
307
 
339
345
  void                    *clientdata;          /* Language specific module data */
340
346
} swig_module_info;
341
347
 
342
 
/* 
 
348
/*
343
349
  Compare two type names skipping the space characters, therefore
344
350
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
345
351
 
359
365
 
360
366
/*
361
367
  Check type equivalence in a name list like <name1>|<name2>|...
 
368
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 
369
*/
 
370
SWIGRUNTIME int
 
371
SWIG_TypeCmp(const char *nb, const char *tb) {
 
372
  int equiv = 1;
 
373
  const char* te = tb + strlen(tb);
 
374
  const char* ne = nb;
 
375
  while (equiv != 0 && *ne) {
 
376
    for (nb = ne; *ne; ++ne) {
 
377
      if (*ne == '|') break;
 
378
    }
 
379
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
 
380
    if (*ne) ++ne;
 
381
  }
 
382
  return equiv;
 
383
}
 
384
 
 
385
/*
 
386
  Check type equivalence in a name list like <name1>|<name2>|...
362
387
  Return 0 if not equal, 1 if equal
363
388
*/
364
389
SWIGRUNTIME int
365
390
SWIG_TypeEquiv(const char *nb, const char *tb) {
366
 
  int equiv = 0;
367
 
  const char* te = tb + strlen(tb);
368
 
  const char* ne = nb;
369
 
  while (!equiv && *ne) {
370
 
    for (nb = ne; *ne; ++ne) {
371
 
      if (*ne == '|') break;
372
 
    }
373
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
374
 
    if (*ne) ++ne;
375
 
  }
376
 
  return equiv;
377
 
}
378
 
 
379
 
/*
380
 
  Check type equivalence in a name list like <name1>|<name2>|...
381
 
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
382
 
*/
383
 
SWIGRUNTIME int
384
 
SWIG_TypeCompare(const char *nb, const char *tb) {
385
 
  int equiv = 0;
386
 
  const char* te = tb + strlen(tb);
387
 
  const char* ne = nb;
388
 
  while (!equiv && *ne) {
389
 
    for (nb = ne; *ne; ++ne) {
390
 
      if (*ne == '|') break;
391
 
    }
392
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
393
 
    if (*ne) ++ne;
394
 
  }
395
 
  return equiv;
396
 
}
397
 
 
 
391
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
 
392
}
398
393
 
399
394
/*
400
395
  Check the typename
423
418
  return 0;
424
419
}
425
420
 
426
 
/* 
 
421
/*
427
422
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
428
423
*/
429
424
SWIGRUNTIME swig_cast_info *
458
453
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
459
454
}
460
455
 
461
 
/* 
 
456
/*
462
457
   Dynamic pointer casting. Down an inheritance hierarchy
463
458
*/
464
459
SWIGRUNTIME swig_type_info *
502
497
    return type->name;
503
498
}
504
499
 
505
 
/* 
 
500
/*
506
501
   Set the clientdata field for a type
507
502
*/
508
503
SWIGRUNTIME void
510
505
  swig_cast_info *cast = ti->cast;
511
506
  /* if (ti->clientdata == clientdata) return; */
512
507
  ti->clientdata = clientdata;
513
 
  
 
508
 
514
509
  while (cast) {
515
510
    if (!cast->converter) {
516
511
      swig_type_info *tc = cast->type;
517
512
      if (!tc->clientdata) {
518
513
        SWIG_TypeClientData(tc, clientdata);
519
514
      }
520
 
    }    
 
515
    }
521
516
    cast = cast->next;
522
517
  }
523
518
}
526
521
  SWIG_TypeClientData(ti, clientdata);
527
522
  ti->owndata = 1;
528
523
}
529
 
  
 
524
 
530
525
/*
531
526
  Search for a swig_type_info structure only by mangled name
532
527
  Search is a O(log #types)
533
 
  
534
 
  We start searching at module start, and finish searching when start == end.  
 
528
 
 
529
  We start searching at module start, and finish searching when start == end.
535
530
  Note: if start == end at the beginning of the function, we go all the way around
536
531
  the circular list.
537
532
*/
538
533
SWIGRUNTIME swig_type_info *
539
 
SWIG_MangledTypeQueryModule(swig_module_info *start, 
540
 
                            swig_module_info *end, 
 
534
SWIG_MangledTypeQueryModule(swig_module_info *start,
 
535
                            swig_module_info *end,
541
536
                            const char *name) {
542
537
  swig_module_info *iter = start;
543
538
  do {
546
541
      register size_t r = iter->size - 1;
547
542
      do {
548
543
        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
549
 
        register size_t i = (l + r) >> 1; 
 
544
        register size_t i = (l + r) >> 1;
550
545
        const char *iname = iter->types[i]->name;
551
546
        if (iname) {
552
547
          register int compare = strcmp(name, iname);
553
 
          if (compare == 0) {       
 
548
          if (compare == 0) {
554
549
            return iter->types[i];
555
550
          } else if (compare < 0) {
556
551
            if (i) {
575
570
  Search for a swig_type_info structure for either a mangled name or a human readable name.
576
571
  It first searches the mangled names of the types, which is a O(log #types)
577
572
  If a type is not found it then searches the human readable names, which is O(#types).
578
 
  
579
 
  We start searching at module start, and finish searching when start == end.  
 
573
 
 
574
  We start searching at module start, and finish searching when start == end.
580
575
  Note: if start == end at the beginning of the function, we go all the way around
581
576
  the circular list.
582
577
*/
583
578
SWIGRUNTIME swig_type_info *
584
 
SWIG_TypeQueryModule(swig_module_info *start, 
585
 
                     swig_module_info *end, 
 
579
SWIG_TypeQueryModule(swig_module_info *start,
 
580
                     swig_module_info *end,
586
581
                     const char *name) {
587
582
  /* STEP 1: Search the name field using binary search */
588
583
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
601
596
      iter = iter->next;
602
597
    } while (iter != end);
603
598
  }
604
 
  
 
599
 
605
600
  /* neither found a match */
606
601
  return 0;
607
602
}
608
603
 
609
 
/* 
 
604
/*
610
605
   Pack binary data into a string
611
606
*/
612
607
SWIGRUNTIME char *
622
617
  return c;
623
618
}
624
619
 
625
 
/* 
 
620
/*
626
621
   Unpack binary data from a string
627
622
*/
628
623
SWIGRUNTIME const char *
636
631
      uu = ((d - '0') << 4);
637
632
    else if ((d >= 'a') && (d <= 'f'))
638
633
      uu = ((d - ('a'-10)) << 4);
639
 
    else 
 
634
    else
640
635
      return (char *) 0;
641
636
    d = *(c++);
642
637
    if ((d >= '0') && (d <= '9'))
643
638
      uu |= (d - '0');
644
639
    else if ((d >= 'a') && (d <= 'f'))
645
640
      uu |= (d - ('a'-10));
646
 
    else 
 
641
    else
647
642
      return (char *) 0;
648
643
    *u = uu;
649
644
  }
650
645
  return c;
651
646
}
652
647
 
653
 
/* 
 
648
/*
654
649
   Pack 'void *' into a string buffer.
655
650
*/
656
651
SWIGRUNTIME char *
710
705
#endif
711
706
 
712
707
/*  Errors in SWIG */
713
 
#define  SWIG_UnknownError         -1 
714
 
#define  SWIG_IOError              -2 
715
 
#define  SWIG_RuntimeError         -3 
716
 
#define  SWIG_IndexError           -4 
717
 
#define  SWIG_TypeError            -5 
718
 
#define  SWIG_DivisionByZero       -6 
719
 
#define  SWIG_OverflowError        -7 
720
 
#define  SWIG_SyntaxError          -8 
721
 
#define  SWIG_ValueError           -9 
 
708
#define  SWIG_UnknownError         -1
 
709
#define  SWIG_IOError              -2
 
710
#define  SWIG_RuntimeError         -3
 
711
#define  SWIG_IndexError           -4
 
712
#define  SWIG_TypeError            -5
 
713
#define  SWIG_DivisionByZero       -6
 
714
#define  SWIG_OverflowError        -7
 
715
#define  SWIG_SyntaxError          -8
 
716
#define  SWIG_ValueError           -9
722
717
#define  SWIG_SystemError          -10
723
718
#define  SWIG_AttributeError       -11
724
 
#define  SWIG_MemoryError          -12 
 
719
#define  SWIG_MemoryError          -12
725
720
#define  SWIG_NullReferenceError   -13
726
721
 
727
722
 
1582
1577
}
1583
1578
 
1584
1579
SWIGRUNTIME int
1585
 
SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1586
 
{
1587
 
  char *str;
1588
 
#ifdef METH_NOARGS
1589
 
  PyObject *repr = SwigPyObject_repr(v);
1590
 
#else
1591
 
  PyObject *repr = SwigPyObject_repr(v, NULL);
1592
 
#endif
1593
 
  if (repr) {
1594
 
    str = SWIG_Python_str_AsChar(repr); 
1595
 
    fputs(str, fp);
1596
 
    SWIG_Python_str_DelForPy3(str);
1597
 
    Py_DECREF(repr);
1598
 
    return 0; 
1599
 
  } else {
1600
 
    return 1; 
1601
 
  }
1602
 
}
1603
 
 
1604
 
SWIGRUNTIME PyObject *
1605
 
SwigPyObject_str(SwigPyObject *v)
1606
 
{
1607
 
  char result[SWIG_BUFFER_SIZE];
1608
 
  return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1609
 
    SWIG_Python_str_FromChar(result) : 0;
1610
 
}
1611
 
 
1612
 
SWIGRUNTIME int
1613
1580
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1614
1581
{
1615
1582
  void *i = v->ptr;
1801
1768
static PyMethodDef
1802
1769
swigobject_methods[] = {
1803
1770
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1804
 
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
 
1771
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
1805
1772
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1806
1773
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
1807
1774
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1894
1861
      sizeof(SwigPyObject),                 /* tp_basicsize */
1895
1862
      0,                                    /* tp_itemsize */
1896
1863
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
1897
 
      (printfunc)SwigPyObject_print,        /* tp_print */
 
1864
      0,                                    /* tp_print */
1898
1865
#if PY_VERSION_HEX < 0x02020000
1899
1866
      (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
1900
1867
#else
1912
1879
      0,                                    /* tp_as_mapping */
1913
1880
      (hashfunc)0,                          /* tp_hash */
1914
1881
      (ternaryfunc)0,                       /* tp_call */
1915
 
      (reprfunc)SwigPyObject_str,           /* tp_str */
 
1882
      0,                                    /* tp_str */
1916
1883
      PyObject_GenericGetAttr,              /* tp_getattro */
1917
1884
      0,                                    /* tp_setattro */
1918
1885
      0,                                    /* tp_as_buffer */
2289
2256
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2290
2257
  int res;
2291
2258
  SwigPyObject *sobj;
 
2259
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2292
2260
 
2293
2261
  if (!obj)
2294
2262
    return SWIG_ERROR;
2295
 
  if (obj == Py_None) {
 
2263
  if (obj == Py_None && !implicit_conv) {
2296
2264
    if (ptr)
2297
2265
      *ptr = 0;
2298
2266
    return SWIG_OK;
2341
2309
    }
2342
2310
    res = SWIG_OK;
2343
2311
  } else {
2344
 
    if (flags & SWIG_POINTER_IMPLICIT_CONV) {
 
2312
    if (implicit_conv) {
2345
2313
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2346
2314
      if (data && !data->implicitconv) {
2347
2315
        PyObject *klass = data->klass;
2376
2344
        }
2377
2345
      }
2378
2346
    }
 
2347
    if (!SWIG_IsOK(res) && obj == Py_None) {
 
2348
      if (ptr)
 
2349
        *ptr = 0;
 
2350
      if (PyErr_Occurred())
 
2351
        PyErr_Clear();
 
2352
      res = SWIG_OK;
 
2353
    }
2379
2354
  }
2380
2355
  return res;
2381
2356
}
2875
2850
  PyObject *descr;
2876
2851
  PyObject *encoded_name;
2877
2852
  descrsetfunc f;
2878
 
  int res;
 
2853
  int res = -1;
2879
2854
 
2880
2855
# ifdef Py_USING_UNICODE
2881
2856
  if (PyString_Check(name)) {
2898
2873
      goto done;
2899
2874
  }
2900
2875
 
2901
 
  res = -1;
2902
2876
  descr = _PyType_Lookup(tp, name);
2903
2877
  f = NULL;
2904
2878
  if (descr != NULL)
2945
2919
#define SWIGTYPE_p_apr_int32_t swig_types[2]
2946
2920
#define SWIGTYPE_p_apr_int64_t swig_types[3]
2947
2921
#define SWIGTYPE_p_apr_pool_t swig_types[4]
2948
 
#define SWIGTYPE_p_char swig_types[5]
2949
 
#define SWIGTYPE_p_f_long_p_void_p_apr_pool_t__void swig_types[6]
2950
 
#define SWIGTYPE_p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[7]
2951
 
#define SWIGTYPE_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[8]
2952
 
#define SWIGTYPE_p_f_p_void__p_svn_error_t swig_types[9]
2953
 
#define SWIGTYPE_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t swig_types[10]
2954
 
#define SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t swig_types[11]
2955
 
#define SWIGTYPE_p_f_p_void_p_struct_svn_error_t__void swig_types[12]
2956
 
#define SWIGTYPE_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t swig_types[13]
2957
 
#define SWIGTYPE_p_int swig_types[14]
2958
 
#define SWIGTYPE_p_long swig_types[15]
2959
 
#define SWIGTYPE_p_p_apr_array_header_t swig_types[16]
2960
 
#define SWIGTYPE_p_p_apr_hash_t swig_types[17]
2961
 
#define SWIGTYPE_p_p_char swig_types[18]
2962
 
#define SWIGTYPE_p_p_f_long_p_void_p_apr_pool_t__void swig_types[19]
2963
 
#define SWIGTYPE_p_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[20]
2964
 
#define SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t swig_types[21]
2965
 
#define SWIGTYPE_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t swig_types[22]
2966
 
#define SWIGTYPE_p_p_f_p_void_p_apr_pool_t__p_svn_error_t swig_types[23]
2967
 
#define SWIGTYPE_p_p_f_p_void_p_struct_svn_error_t__void swig_types[24]
2968
 
#define SWIGTYPE_p_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t swig_types[25]
2969
 
#define SWIGTYPE_p_p_svn_checksum_t swig_types[26]
2970
 
#define SWIGTYPE_p_p_svn_fs_access_t swig_types[27]
2971
 
#define SWIGTYPE_p_p_svn_fs_history_t swig_types[28]
2972
 
#define SWIGTYPE_p_p_svn_fs_id_t swig_types[29]
2973
 
#define SWIGTYPE_p_p_svn_fs_root_t swig_types[30]
2974
 
#define SWIGTYPE_p_p_svn_fs_t swig_types[31]
2975
 
#define SWIGTYPE_p_p_svn_fs_txn_t swig_types[32]
2976
 
#define SWIGTYPE_p_p_svn_lock_t swig_types[33]
2977
 
#define SWIGTYPE_p_p_svn_stream_t swig_types[34]
2978
 
#define SWIGTYPE_p_p_svn_string_t swig_types[35]
2979
 
#define SWIGTYPE_p_p_svn_txdelta_stream_t swig_types[36]
2980
 
#define SWIGTYPE_p_p_void swig_types[37]
2981
 
#define SWIGTYPE_p_svn_auth_baton_t swig_types[38]
2982
 
#define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[39]
2983
 
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[40]
2984
 
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[41]
2985
 
#define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[42]
2986
 
#define SWIGTYPE_p_svn_auth_cred_username_t swig_types[43]
2987
 
#define SWIGTYPE_p_svn_auth_iterstate_t swig_types[44]
2988
 
#define SWIGTYPE_p_svn_auth_provider_object_t swig_types[45]
2989
 
#define SWIGTYPE_p_svn_auth_provider_t swig_types[46]
2990
 
#define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[47]
2991
 
#define SWIGTYPE_p_svn_checksum_ctx_t swig_types[48]
2992
 
#define SWIGTYPE_p_svn_checksum_kind_t swig_types[49]
2993
 
#define SWIGTYPE_p_svn_checksum_t swig_types[50]
2994
 
#define SWIGTYPE_p_svn_commit_info_t swig_types[51]
2995
 
#define SWIGTYPE_p_svn_config_t swig_types[52]
2996
 
#define SWIGTYPE_p_svn_delta_editor_t swig_types[53]
2997
 
#define SWIGTYPE_p_svn_depth_t swig_types[54]
2998
 
#define SWIGTYPE_p_svn_dirent_t swig_types[55]
2999
 
#define SWIGTYPE_p_svn_errno_t swig_types[56]
3000
 
#define SWIGTYPE_p_svn_error_t swig_types[57]
3001
 
#define SWIGTYPE_p_svn_fs_access_t swig_types[58]
3002
 
#define SWIGTYPE_p_svn_fs_dirent_t swig_types[59]
3003
 
#define SWIGTYPE_p_svn_fs_history_t swig_types[60]
3004
 
#define SWIGTYPE_p_svn_fs_id_t swig_types[61]
3005
 
#define SWIGTYPE_p_svn_fs_pack_notify_action_t swig_types[62]
3006
 
#define SWIGTYPE_p_svn_fs_path_change2_t swig_types[63]
3007
 
#define SWIGTYPE_p_svn_fs_path_change_kind_t swig_types[64]
3008
 
#define SWIGTYPE_p_svn_fs_path_change_t swig_types[65]
3009
 
#define SWIGTYPE_p_svn_fs_root_t swig_types[66]
3010
 
#define SWIGTYPE_p_svn_fs_t swig_types[67]
3011
 
#define SWIGTYPE_p_svn_fs_txn_t swig_types[68]
3012
 
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[69]
3013
 
#define SWIGTYPE_p_svn_io_dirent_t swig_types[70]
3014
 
#define SWIGTYPE_p_svn_io_file_del_t swig_types[71]
3015
 
#define SWIGTYPE_p_svn_location_segment_t swig_types[72]
3016
 
#define SWIGTYPE_p_svn_lock_t swig_types[73]
3017
 
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[74]
3018
 
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[75]
3019
 
#define SWIGTYPE_p_svn_log_entry_t swig_types[76]
3020
 
#define SWIGTYPE_p_svn_merge_range_t swig_types[77]
3021
 
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[78]
3022
 
#define SWIGTYPE_p_svn_node_kind_t swig_types[79]
3023
 
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[80]
3024
 
#define SWIGTYPE_p_svn_opt_revision_t swig_types[81]
3025
 
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[82]
3026
 
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[83]
3027
 
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[84]
3028
 
#define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[85]
3029
 
#define SWIGTYPE_p_svn_prop_kind swig_types[86]
3030
 
#define SWIGTYPE_p_svn_stream_mark_t swig_types[87]
3031
 
#define SWIGTYPE_p_svn_stream_t swig_types[88]
3032
 
#define SWIGTYPE_p_svn_string_t swig_types[89]
3033
 
#define SWIGTYPE_p_svn_stringbuf_t swig_types[90]
3034
 
#define SWIGTYPE_p_svn_tristate_t swig_types[91]
3035
 
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[92]
3036
 
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[93]
3037
 
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[94]
3038
 
#define SWIGTYPE_p_svn_version_checklist_t swig_types[95]
3039
 
#define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[96]
3040
 
#define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[97]
3041
 
#define SWIGTYPE_p_svn_version_extended_t swig_types[98]
3042
 
#define SWIGTYPE_p_svn_version_t swig_types[99]
3043
 
#define SWIGTYPE_p_svn_wc_external_item2_t swig_types[100]
3044
 
#define SWIGTYPE_p_unsigned_char swig_types[101]
3045
 
#define SWIGTYPE_p_unsigned_long swig_types[102]
3046
 
#define SWIGTYPE_p_void swig_types[103]
3047
 
static swig_type_info *swig_types[105];
3048
 
static swig_module_info swig_module = {swig_types, 104, 0, 0, 0, 0};
 
2922
#define SWIGTYPE_p_apr_uint64_t swig_types[5]
 
2923
#define SWIGTYPE_p_char swig_types[6]
 
2924
#define SWIGTYPE_p_f_long_p_void_p_apr_pool_t__void swig_types[7]
 
2925
#define SWIGTYPE_p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[8]
 
2926
#define SWIGTYPE_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[9]
 
2927
#define SWIGTYPE_p_f_p_void__p_svn_error_t swig_types[10]
 
2928
#define SWIGTYPE_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t swig_types[11]
 
2929
#define SWIGTYPE_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t swig_types[12]
 
2930
#define SWIGTYPE_p_f_p_void_long_long_p_apr_pool_t__void swig_types[13]
 
2931
#define SWIGTYPE_p_f_p_void_p_apr_pool_t__p_svn_error_t swig_types[14]
 
2932
#define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t swig_types[15]
 
2933
#define SWIGTYPE_p_f_p_void_p_struct_svn_error_t__void swig_types[16]
 
2934
#define SWIGTYPE_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t swig_types[17]
 
2935
#define SWIGTYPE_p_int swig_types[18]
 
2936
#define SWIGTYPE_p_long swig_types[19]
 
2937
#define SWIGTYPE_p_p_apr_array_header_t swig_types[20]
 
2938
#define SWIGTYPE_p_p_apr_hash_t swig_types[21]
 
2939
#define SWIGTYPE_p_p_char swig_types[22]
 
2940
#define SWIGTYPE_p_p_f_long_p_void_p_apr_pool_t__void swig_types[23]
 
2941
#define SWIGTYPE_p_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t swig_types[24]
 
2942
#define SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t swig_types[25]
 
2943
#define SWIGTYPE_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t swig_types[26]
 
2944
#define SWIGTYPE_p_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t swig_types[27]
 
2945
#define SWIGTYPE_p_p_f_p_void_long_long_p_apr_pool_t__void swig_types[28]
 
2946
#define SWIGTYPE_p_p_f_p_void_p_apr_pool_t__p_svn_error_t swig_types[29]
 
2947
#define SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t swig_types[30]
 
2948
#define SWIGTYPE_p_p_f_p_void_p_struct_svn_error_t__void swig_types[31]
 
2949
#define SWIGTYPE_p_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t swig_types[32]
 
2950
#define SWIGTYPE_p_p_svn_checksum_t swig_types[33]
 
2951
#define SWIGTYPE_p_p_svn_fs_access_t swig_types[34]
 
2952
#define SWIGTYPE_p_p_svn_fs_history_t swig_types[35]
 
2953
#define SWIGTYPE_p_p_svn_fs_id_t swig_types[36]
 
2954
#define SWIGTYPE_p_p_svn_fs_info_placeholder_t swig_types[37]
 
2955
#define SWIGTYPE_p_p_svn_fs_root_t swig_types[38]
 
2956
#define SWIGTYPE_p_p_svn_fs_t swig_types[39]
 
2957
#define SWIGTYPE_p_p_svn_fs_txn_t swig_types[40]
 
2958
#define SWIGTYPE_p_p_svn_lock_t swig_types[41]
 
2959
#define SWIGTYPE_p_p_svn_stream_t swig_types[42]
 
2960
#define SWIGTYPE_p_p_svn_string_t swig_types[43]
 
2961
#define SWIGTYPE_p_p_svn_txdelta_stream_t swig_types[44]
 
2962
#define SWIGTYPE_p_p_svn_version_t swig_types[45]
 
2963
#define SWIGTYPE_p_p_void swig_types[46]
 
2964
#define SWIGTYPE_p_svn_auth_baton_t swig_types[47]
 
2965
#define SWIGTYPE_p_svn_auth_cred_simple_t swig_types[48]
 
2966
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_pw_t swig_types[49]
 
2967
#define SWIGTYPE_p_svn_auth_cred_ssl_client_cert_t swig_types[50]
 
2968
#define SWIGTYPE_p_svn_auth_cred_ssl_server_trust_t swig_types[51]
 
2969
#define SWIGTYPE_p_svn_auth_cred_username_t swig_types[52]
 
2970
#define SWIGTYPE_p_svn_auth_iterstate_t swig_types[53]
 
2971
#define SWIGTYPE_p_svn_auth_provider_object_t swig_types[54]
 
2972
#define SWIGTYPE_p_svn_auth_provider_t swig_types[55]
 
2973
#define SWIGTYPE_p_svn_auth_ssl_server_cert_info_t swig_types[56]
 
2974
#define SWIGTYPE_p_svn_checksum_ctx_t swig_types[57]
 
2975
#define SWIGTYPE_p_svn_checksum_kind_t swig_types[58]
 
2976
#define SWIGTYPE_p_svn_checksum_t swig_types[59]
 
2977
#define SWIGTYPE_p_svn_commit_info_t swig_types[60]
 
2978
#define SWIGTYPE_p_svn_config_t swig_types[61]
 
2979
#define SWIGTYPE_p_svn_delta_editor_t swig_types[62]
 
2980
#define SWIGTYPE_p_svn_depth_t swig_types[63]
 
2981
#define SWIGTYPE_p_svn_diff_hunk_t swig_types[64]
 
2982
#define SWIGTYPE_p_svn_dirent_t swig_types[65]
 
2983
#define SWIGTYPE_p_svn_errno_t swig_types[66]
 
2984
#define SWIGTYPE_p_svn_error_t swig_types[67]
 
2985
#define SWIGTYPE_p_svn_fs_access_t swig_types[68]
 
2986
#define SWIGTYPE_p_svn_fs_dirent_t swig_types[69]
 
2987
#define SWIGTYPE_p_svn_fs_fsfs_info_t swig_types[70]
 
2988
#define SWIGTYPE_p_svn_fs_fsx_info_t swig_types[71]
 
2989
#define SWIGTYPE_p_svn_fs_history_t swig_types[72]
 
2990
#define SWIGTYPE_p_svn_fs_id_t swig_types[73]
 
2991
#define SWIGTYPE_p_svn_fs_info_placeholder_t swig_types[74]
 
2992
#define SWIGTYPE_p_svn_fs_lock_target_t swig_types[75]
 
2993
#define SWIGTYPE_p_svn_fs_node_relation_t swig_types[76]
 
2994
#define SWIGTYPE_p_svn_fs_pack_notify_action_t swig_types[77]
 
2995
#define SWIGTYPE_p_svn_fs_path_change2_t swig_types[78]
 
2996
#define SWIGTYPE_p_svn_fs_path_change_kind_t swig_types[79]
 
2997
#define SWIGTYPE_p_svn_fs_path_change_t swig_types[80]
 
2998
#define SWIGTYPE_p_svn_fs_root_t swig_types[81]
 
2999
#define SWIGTYPE_p_svn_fs_t swig_types[82]
 
3000
#define SWIGTYPE_p_svn_fs_txn_t swig_types[83]
 
3001
#define SWIGTYPE_p_svn_fs_upgrade_notify_action_t swig_types[84]
 
3002
#define SWIGTYPE_p_svn_io_dirent2_t swig_types[85]
 
3003
#define SWIGTYPE_p_svn_io_dirent_t swig_types[86]
 
3004
#define SWIGTYPE_p_svn_io_file_del_t swig_types[87]
 
3005
#define SWIGTYPE_p_svn_location_segment_t swig_types[88]
 
3006
#define SWIGTYPE_p_svn_lock_t swig_types[89]
 
3007
#define SWIGTYPE_p_svn_log_changed_path2_t swig_types[90]
 
3008
#define SWIGTYPE_p_svn_log_changed_path_t swig_types[91]
 
3009
#define SWIGTYPE_p_svn_log_entry_t swig_types[92]
 
3010
#define SWIGTYPE_p_svn_merge_range_t swig_types[93]
 
3011
#define SWIGTYPE_p_svn_mergeinfo_inheritance_t swig_types[94]
 
3012
#define SWIGTYPE_p_svn_node_kind_t swig_types[95]
 
3013
#define SWIGTYPE_p_svn_opt_revision_range_t swig_types[96]
 
3014
#define SWIGTYPE_p_svn_opt_revision_t swig_types[97]
 
3015
#define SWIGTYPE_p_svn_opt_revision_value_t swig_types[98]
 
3016
#define SWIGTYPE_p_svn_opt_subcommand_desc2_t swig_types[99]
 
3017
#define SWIGTYPE_p_svn_opt_subcommand_desc_t swig_types[100]
 
3018
#define SWIGTYPE_p_svn_prop_inherited_item_t swig_types[101]
 
3019
#define SWIGTYPE_p_svn_prop_kind swig_types[102]
 
3020
#define SWIGTYPE_p_svn_stream_mark_t swig_types[103]
 
3021
#define SWIGTYPE_p_svn_stream_t swig_types[104]
 
3022
#define SWIGTYPE_p_svn_string_t swig_types[105]
 
3023
#define SWIGTYPE_p_svn_stringbuf_t swig_types[106]
 
3024
#define SWIGTYPE_p_svn_tristate_t swig_types[107]
 
3025
#define SWIGTYPE_p_svn_txdelta_op_t swig_types[108]
 
3026
#define SWIGTYPE_p_svn_txdelta_stream_t swig_types[109]
 
3027
#define SWIGTYPE_p_svn_txdelta_window_t swig_types[110]
 
3028
#define SWIGTYPE_p_svn_version_checklist_t swig_types[111]
 
3029
#define SWIGTYPE_p_svn_version_ext_linked_lib_t swig_types[112]
 
3030
#define SWIGTYPE_p_svn_version_ext_loaded_lib_t swig_types[113]
 
3031
#define SWIGTYPE_p_svn_version_extended_t swig_types[114]
 
3032
#define SWIGTYPE_p_svn_version_t swig_types[115]
 
3033
#define SWIGTYPE_p_svn_wc_external_item2_t swig_types[116]
 
3034
#define SWIGTYPE_p_unsigned_char swig_types[117]
 
3035
#define SWIGTYPE_p_unsigned_long swig_types[118]
 
3036
#define SWIGTYPE_p_void swig_types[119]
 
3037
static swig_type_info *swig_types[121];
 
3038
static swig_module_info swig_module = {swig_types, 120, 0, 0, 0, 0};
3049
3039
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3050
3040
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3051
3041
 
3069
3059
#endif
3070
3060
#define SWIG_name    "_fs"
3071
3061
 
3072
 
#define SWIGVERSION 0x020009 
 
3062
#define SWIGVERSION 0x020012 
3073
3063
#define SWIG_VERSION SWIGVERSION
3074
3064
 
3075
3065
 
3256
3246
 
3257
3247
 
3258
3248
 
 
3249
  #define SWIG_From_long   PyLong_FromLong 
 
3250
 
 
3251
 
3259
3252
SWIGINTERN int
3260
3253
SWIG_AsVal_double (PyObject *obj, double *val)
3261
3254
{
3391
3384
}
3392
3385
 
3393
3386
 
3394
 
  #define SWIG_From_long   PyLong_FromLong 
3395
 
 
3396
 
 
3397
3387
SWIGINTERN int
3398
3388
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
3399
3389
{
3415
3405
      return SWIG_OK;
3416
3406
    } else {
3417
3407
      PyErr_Clear();
 
3408
#if PY_VERSION_HEX >= 0x03000000
 
3409
      {
 
3410
        long v = PyLong_AsLong(obj);
 
3411
        if (!PyErr_Occurred()) {
 
3412
          if (v < 0) {
 
3413
            return SWIG_OverflowError;
 
3414
          }
 
3415
        } else {
 
3416
          PyErr_Clear();
 
3417
        }
 
3418
      }
 
3419
#endif
3418
3420
    }
3419
3421
  }
3420
3422
#ifdef SWIG_PYTHON_CAST_MODE
3469
3471
  _obj(baton, err);
3470
3472
}
3471
3473
 
 
3474
static svn_error_t * svn_fs_invoke_upgrade_notify(
 
3475
  svn_fs_upgrade_notify_t _obj, void *baton, apr_uint64_t number, svn_fs_upgrade_notify_action_t action, apr_pool_t *scratch_pool) {
 
3476
  return _obj(baton, number, action, scratch_pool);
 
3477
}
 
3478
 
3472
3479
static void svn_fs_invoke_progress_notify_func(
3473
3480
  svn_fs_progress_notify_func_t _obj, svn_revnum_t revision, void *baton, apr_pool_t *pool) {
3474
3481
  _obj(revision, baton, pool);
3475
3482
}
3476
3483
 
 
3484
static void svn_fs_invoke_hotcopy_notify(
 
3485
  svn_fs_hotcopy_notify_t _obj, void *baton, svn_revnum_t start_revision, svn_revnum_t end_revision, apr_pool_t *scratch_pool) {
 
3486
  _obj(baton, start_revision, end_revision, scratch_pool);
 
3487
}
 
3488
 
3477
3489
static svn_error_t * svn_fs_invoke_freeze_func(
3478
3490
  svn_fs_freeze_func_t _obj, void *baton, apr_pool_t *pool) {
3479
3491
  return _obj(baton, pool);
3484
3496
  return _obj(contents, len, baton, scratch_pool);
3485
3497
}
3486
3498
 
 
3499
static svn_error_t * svn_fs_invoke_lock_callback(
 
3500
  svn_fs_lock_callback_t _obj, void *baton, const char *path, const svn_lock_t *lock, svn_error_t *fs_err, apr_pool_t *scratch_pool) {
 
3501
  return _obj(baton, path, lock, fs_err, scratch_pool);
 
3502
}
 
3503
 
3487
3504
static svn_error_t * svn_fs_invoke_get_locks_callback(
3488
3505
  svn_fs_get_locks_callback_t _obj, void *baton, svn_lock_t *lock, apr_pool_t *pool) {
3489
3506
  return _obj(baton, lock, pool);
3511
3528
    svn_swig_py_acquire_py_lock();
3512
3529
    
3513
3530
  }
3514
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_version_t,
 
3531
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_version_t,
3515
3532
    _global_py_pool, args);
3516
3533
  return resultobj;
3517
3534
fail:
3622
3639
    resultobj = Py_None;
3623
3640
  }
3624
3641
  {
3625
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_t,
3626
 
        _global_py_pool, args))
3627
 
    
3628
 
    ;
3629
 
  }
3630
 
  {
3631
 
    Py_XDECREF(_global_py_pool);
3632
 
  }
3633
 
  return resultobj;
3634
 
fail:
 
3642
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_t,
 
3643
        _global_py_pool, args))
 
3644
    
 
3645
    ;
 
3646
  }
 
3647
  {
 
3648
    Py_XDECREF(_global_py_pool);
 
3649
  }
 
3650
  return resultobj;
 
3651
fail:
 
3652
  {
 
3653
    Py_XDECREF(_global_py_pool);
 
3654
  }
 
3655
  return NULL;
 
3656
}
 
3657
 
 
3658
 
 
3659
SWIGINTERN PyObject *_wrap_svn_fs_open2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3660
  PyObject *resultobj = 0;
 
3661
  svn_fs_t **arg1 = (svn_fs_t **) 0 ;
 
3662
  char *arg2 = (char *) 0 ;
 
3663
  apr_hash_t *arg3 = (apr_hash_t *) 0 ;
 
3664
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
3665
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
3666
  apr_pool_t *_global_pool = NULL ;
 
3667
  PyObject *_global_py_pool = NULL ;
 
3668
  svn_fs_t *temp1 ;
 
3669
  PyObject * obj1 = 0 ;
 
3670
  PyObject * obj2 = 0 ;
 
3671
  PyObject * obj3 = 0 ;
 
3672
  svn_error_t *result = 0 ;
 
3673
  
 
3674
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
3675
      &_global_py_pool, &_global_pool))
 
3676
  SWIG_fail;
 
3677
  arg4 = _global_pool;
 
3678
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
3679
      &_global_py_pool, &_global_pool))
 
3680
  SWIG_fail;
 
3681
  arg5 = _global_pool;
 
3682
  arg1 = &temp1;
 
3683
  if (!PyArg_ParseTuple(args,(char *)"sO|OO:svn_fs_open2",&arg2,&obj1,&obj2,&obj3)) SWIG_fail;
 
3684
  {
 
3685
    /* PYTHON-FIXME: Handle None -> NULL. */
 
3686
    arg3 = svn_swig_py_stringhash_from_dict(obj1, _global_pool);
 
3687
  }
 
3688
  if (obj2) {
 
3689
    /* Verify that the user supplied a valid pool */
 
3690
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
3691
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
3692
      SWIG_arg_fail(svn_argnum_obj2);
 
3693
      SWIG_fail;
 
3694
    }
 
3695
  }
 
3696
  if (obj3) {
 
3697
    /* Verify that the user supplied a valid pool */
 
3698
    if (obj3 != Py_None && obj3 != _global_py_pool) {
 
3699
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
 
3700
      SWIG_arg_fail(svn_argnum_obj3);
 
3701
      SWIG_fail;
 
3702
    }
 
3703
  }
 
3704
  {
 
3705
    svn_swig_py_release_py_lock();
 
3706
    
 
3707
    result = (svn_error_t *)svn_fs_open2(arg1,(char const *)arg2,arg3,arg4,arg5);
 
3708
    
 
3709
    svn_swig_py_acquire_py_lock();
 
3710
    
 
3711
  }
 
3712
  {
 
3713
    if (result != NULL) {
 
3714
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
3715
      svn_swig_py_svn_exception(result);
 
3716
      else
 
3717
      svn_error_clear(result);
 
3718
      SWIG_fail;
 
3719
    }
 
3720
    Py_INCREF(Py_None);
 
3721
    resultobj = Py_None;
 
3722
  }
 
3723
  {
 
3724
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_t,
 
3725
        _global_py_pool, args))
 
3726
    
 
3727
    ;
 
3728
  }
 
3729
  {
 
3730
    Py_XDECREF(_global_py_pool);
 
3731
  }
 
3732
  {
 
3733
    Py_XDECREF(_global_py_pool);
 
3734
  }
 
3735
  return resultobj;
 
3736
fail:
 
3737
  {
 
3738
    Py_XDECREF(_global_py_pool);
 
3739
  }
3635
3740
  {
3636
3741
    Py_XDECREF(_global_py_pool);
3637
3742
  }
3690
3795
    resultobj = Py_None;
3691
3796
  }
3692
3797
  {
3693
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_t,
 
3798
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_t,
3694
3799
        _global_py_pool, args))
3695
3800
    
3696
3801
    ;
3707
3812
}
3708
3813
 
3709
3814
 
 
3815
SWIGINTERN PyObject *_wrap_svn_fs_upgrade2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3816
  PyObject *resultobj = 0;
 
3817
  char *arg1 = (char *) 0 ;
 
3818
  svn_fs_upgrade_notify_t arg2 = (svn_fs_upgrade_notify_t) 0 ;
 
3819
  void *arg3 = (void *) 0 ;
 
3820
  svn_cancel_func_t arg4 = (svn_cancel_func_t) 0 ;
 
3821
  void *arg5 = (void *) 0 ;
 
3822
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
3823
  apr_pool_t *_global_pool = NULL ;
 
3824
  PyObject *_global_py_pool = NULL ;
 
3825
  PyObject * obj1 = 0 ;
 
3826
  PyObject * obj2 = 0 ;
 
3827
  PyObject * obj3 = 0 ;
 
3828
  PyObject * obj4 = 0 ;
 
3829
  svn_error_t *result = 0 ;
 
3830
  
 
3831
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
3832
      &_global_py_pool, &_global_pool))
 
3833
  SWIG_fail;
 
3834
  arg6 = _global_pool;
 
3835
  if (!PyArg_ParseTuple(args,(char *)"sOOO|O:svn_fs_upgrade2",&arg1,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
3836
  {
 
3837
    svn_fs_upgrade_notify_t * tmp =
 
3838
    svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj1);
 
3839
    if (tmp == NULL || PyErr_Occurred()) {
 
3840
      SWIG_fail;
 
3841
    }
 
3842
    arg2 = *tmp;
 
3843
  }
 
3844
  {
 
3845
    if (obj2 == Py_None) {
 
3846
      arg3 = NULL;
 
3847
    } else if (SWIG_ConvertPtr(obj2, (void **) &arg3, 0, 0) == -1) {
 
3848
      arg3 = (void *) obj2;
 
3849
      PyErr_Clear();
 
3850
    }
 
3851
  }
 
3852
  {
 
3853
    arg4 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
3854
    arg5 = obj3;
 
3855
  }
 
3856
  if (obj4) {
 
3857
    /* Verify that the user supplied a valid pool */
 
3858
    if (obj4 != Py_None && obj4 != _global_py_pool) {
 
3859
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
 
3860
      SWIG_arg_fail(svn_argnum_obj4);
 
3861
      SWIG_fail;
 
3862
    }
 
3863
  }
 
3864
  {
 
3865
    svn_swig_py_release_py_lock();
 
3866
    
 
3867
    result = (svn_error_t *)svn_fs_upgrade2((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
 
3868
    
 
3869
    svn_swig_py_acquire_py_lock();
 
3870
    
 
3871
  }
 
3872
  {
 
3873
    if (result != NULL) {
 
3874
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
3875
      svn_swig_py_svn_exception(result);
 
3876
      else
 
3877
      svn_error_clear(result);
 
3878
      SWIG_fail;
 
3879
    }
 
3880
    Py_INCREF(Py_None);
 
3881
    resultobj = Py_None;
 
3882
  }
 
3883
  {
 
3884
    Py_XDECREF(_global_py_pool);
 
3885
  }
 
3886
  return resultobj;
 
3887
fail:
 
3888
  {
 
3889
    Py_XDECREF(_global_py_pool);
 
3890
  }
 
3891
  return NULL;
 
3892
}
 
3893
 
 
3894
 
3710
3895
SWIGINTERN PyObject *_wrap_svn_fs_upgrade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3711
3896
  PyObject *resultobj = 0;
3712
3897
  char *arg1 = (char *) 0 ;
3845
4030
  arg2 = _global_pool;
3846
4031
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_path",&obj0,&obj1)) SWIG_fail;
3847
4032
  {
3848
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
4033
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
3849
4034
    if (PyErr_Occurred()) {
3850
4035
      SWIG_fail;
3851
4036
    }
3895
4080
  arg2 = _global_pool;
3896
4081
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_config",&obj0,&obj1)) SWIG_fail;
3897
4082
  {
3898
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
4083
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
3899
4084
    if (PyErr_Occurred()) {
3900
4085
      SWIG_fail;
3901
4086
    }
3916
4101
    svn_swig_py_acquire_py_lock();
3917
4102
    
3918
4103
  }
3919
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_apr_hash_t,
 
4104
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_apr_hash_t,
3920
4105
    _global_py_pool, args);
3921
4106
  {
3922
4107
    Py_XDECREF(_global_py_pool);
3983
4168
}
3984
4169
 
3985
4170
 
 
4171
SWIGINTERN PyObject *_wrap_svn_fs_hotcopy3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4172
  PyObject *resultobj = 0;
 
4173
  char *arg1 = (char *) 0 ;
 
4174
  char *arg2 = (char *) 0 ;
 
4175
  svn_boolean_t arg3 ;
 
4176
  svn_boolean_t arg4 ;
 
4177
  svn_fs_hotcopy_notify_t arg5 = (svn_fs_hotcopy_notify_t) 0 ;
 
4178
  void *arg6 = (void *) 0 ;
 
4179
  svn_cancel_func_t arg7 = (svn_cancel_func_t) 0 ;
 
4180
  void *arg8 = (void *) 0 ;
 
4181
  apr_pool_t *arg9 = (apr_pool_t *) 0 ;
 
4182
  apr_pool_t *_global_pool = NULL ;
 
4183
  PyObject *_global_py_pool = NULL ;
 
4184
  PyObject * obj2 = 0 ;
 
4185
  PyObject * obj3 = 0 ;
 
4186
  PyObject * obj4 = 0 ;
 
4187
  PyObject * obj5 = 0 ;
 
4188
  PyObject * obj6 = 0 ;
 
4189
  PyObject * obj7 = 0 ;
 
4190
  svn_error_t *result = 0 ;
 
4191
  
 
4192
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
4193
      &_global_py_pool, &_global_pool))
 
4194
  SWIG_fail;
 
4195
  arg9 = _global_pool;
 
4196
  if (!PyArg_ParseTuple(args,(char *)"ssOOOOO|O:svn_fs_hotcopy3",&arg1,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
4197
  {
 
4198
    arg3 = (svn_boolean_t)SWIG_As_long (obj2);
 
4199
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
4200
      SWIG_fail;
 
4201
    }
 
4202
  }
 
4203
  {
 
4204
    arg4 = (svn_boolean_t)SWIG_As_long (obj3);
 
4205
    if (SWIG_arg_fail(svn_argnum_obj3)) {
 
4206
      SWIG_fail;
 
4207
    }
 
4208
  }
 
4209
  {
 
4210
    svn_fs_hotcopy_notify_t * tmp =
 
4211
    svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_p_f_p_void_long_long_p_apr_pool_t__void, svn_argnum_obj4);
 
4212
    if (tmp == NULL || PyErr_Occurred()) {
 
4213
      SWIG_fail;
 
4214
    }
 
4215
    arg5 = *tmp;
 
4216
  }
 
4217
  {
 
4218
    if (obj5 == Py_None) {
 
4219
      arg6 = NULL;
 
4220
    } else if (SWIG_ConvertPtr(obj5, (void **) &arg6, 0, 0) == -1) {
 
4221
      arg6 = (void *) obj5;
 
4222
      PyErr_Clear();
 
4223
    }
 
4224
  }
 
4225
  {
 
4226
    arg7 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
4227
    arg8 = obj6;
 
4228
  }
 
4229
  if (obj7) {
 
4230
    /* Verify that the user supplied a valid pool */
 
4231
    if (obj7 != Py_None && obj7 != _global_py_pool) {
 
4232
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
 
4233
      SWIG_arg_fail(svn_argnum_obj7);
 
4234
      SWIG_fail;
 
4235
    }
 
4236
  }
 
4237
  {
 
4238
    svn_swig_py_release_py_lock();
 
4239
    
 
4240
    result = (svn_error_t *)svn_fs_hotcopy3((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
 
4241
    
 
4242
    svn_swig_py_acquire_py_lock();
 
4243
    
 
4244
  }
 
4245
  {
 
4246
    if (result != NULL) {
 
4247
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
4248
      svn_swig_py_svn_exception(result);
 
4249
      else
 
4250
      svn_error_clear(result);
 
4251
      SWIG_fail;
 
4252
    }
 
4253
    Py_INCREF(Py_None);
 
4254
    resultobj = Py_None;
 
4255
  }
 
4256
  {
 
4257
    Py_XDECREF(_global_py_pool);
 
4258
  }
 
4259
  return resultobj;
 
4260
fail:
 
4261
  {
 
4262
    Py_XDECREF(_global_py_pool);
 
4263
  }
 
4264
  return NULL;
 
4265
}
 
4266
 
 
4267
 
3986
4268
SWIGINTERN PyObject *_wrap_svn_fs_hotcopy2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3987
4269
  PyObject *resultobj = 0;
3988
4270
  char *arg1 = (char *) 0 ;
4018
4300
    }
4019
4301
  }
4020
4302
  {
4021
 
    arg5 = svn_swig_py_cancel_func;
4022
 
    arg6 = obj4; /* our function is the baton. */
 
4303
    arg5 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
4304
    arg6 = obj4;
4023
4305
  }
4024
4306
  if (obj5) {
4025
4307
    /* Verify that the user supplied a valid pool */
4140
4422
  arg4 = _global_pool;
4141
4423
  if (!PyArg_ParseTuple(args,(char *)"sO|O:svn_fs_recover",&arg1,&obj1,&obj2)) SWIG_fail;
4142
4424
  {
4143
 
    arg2 = svn_swig_py_cancel_func;
4144
 
    arg3 = obj1; /* our function is the baton. */
 
4425
    arg2 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
4426
    arg3 = obj1;
4145
4427
  }
4146
4428
  if (obj2) {
4147
4429
    /* Verify that the user supplied a valid pool */
4201
4483
  arg4 = _global_pool;
4202
4484
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_fs_freeze",&obj0,&obj1,&obj2)) SWIG_fail;
4203
4485
  {
4204
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
4486
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
4205
4487
    if (PyErr_Occurred()) {
4206
4488
      SWIG_fail;
4207
4489
    }
4351
4633
    svn_swig_py_acquire_py_lock();
4352
4634
    
4353
4635
  }
4354
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_fs_t,
 
4636
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_fs_t,
4355
4637
    _global_py_pool, args);
4356
4638
  {
4357
4639
    Py_XDECREF(_global_py_pool);
4374
4656
  
4375
4657
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_fs_create_berkeley",&obj0,&arg2)) SWIG_fail;
4376
4658
  {
4377
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
4659
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
4378
4660
    if (PyErr_Occurred()) {
4379
4661
      SWIG_fail;
4380
4662
    }
4413
4695
  
4414
4696
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_fs_open_berkeley",&obj0,&arg2)) SWIG_fail;
4415
4697
  {
4416
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
4698
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
4417
4699
    if (PyErr_Occurred()) {
4418
4700
      SWIG_fail;
4419
4701
    }
4459
4741
  arg2 = _global_pool;
4460
4742
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_berkeley_path",&obj0,&obj1)) SWIG_fail;
4461
4743
  {
4462
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
4744
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
4463
4745
    if (PyErr_Occurred()) {
4464
4746
      SWIG_fail;
4465
4747
    }
4706
4988
    resultobj = Py_None;
4707
4989
  }
4708
4990
  {
4709
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_access_t,
 
4991
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_access_t,
4710
4992
        _global_py_pool, args))
4711
4993
    
4712
4994
    ;
4733
5015
  
4734
5016
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_set_access",&obj0,&obj1)) SWIG_fail;
4735
5017
  {
4736
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
5018
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
4737
5019
    if (PyErr_Occurred()) {
4738
5020
      SWIG_fail;
4739
5021
    }
4740
5022
  }
4741
5023
  {
4742
 
    arg2 = (svn_fs_access_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_access_t, svn_argnum_obj1);
 
5024
    arg2 = (svn_fs_access_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_access_t, svn_argnum_obj1);
4743
5025
    if (PyErr_Occurred()) {
4744
5026
      SWIG_fail;
4745
5027
    }
4780
5062
  arg1 = &temp1;
4781
5063
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_get_access",&obj0)) SWIG_fail;
4782
5064
  {
4783
 
    arg2 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
5065
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
4784
5066
    if (PyErr_Occurred()) {
4785
5067
      SWIG_fail;
4786
5068
    }
4805
5087
    resultobj = Py_None;
4806
5088
  }
4807
5089
  {
4808
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_access_t,
 
5090
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_access_t,
4809
5091
        _global_py_pool, args))
4810
5092
    
4811
5093
    ;
4827
5109
  arg1 = &temp1;
4828
5110
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_access_get_username",&obj0)) SWIG_fail;
4829
5111
  {
4830
 
    arg2 = (svn_fs_access_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_access_t, svn_argnum_obj0);
 
5112
    arg2 = (svn_fs_access_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_access_t, svn_argnum_obj0);
4831
5113
    if (PyErr_Occurred()) {
4832
5114
      SWIG_fail;
4833
5115
    }
4880
5162
  
4881
5163
  if (!PyArg_ParseTuple(args,(char *)"Osz:svn_fs_access_add_lock_token2",&obj0,&arg2,&arg3)) SWIG_fail;
4882
5164
  {
4883
 
    arg1 = (svn_fs_access_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_access_t, svn_argnum_obj0);
 
5165
    arg1 = (svn_fs_access_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_access_t, svn_argnum_obj0);
4884
5166
    if (PyErr_Occurred()) {
4885
5167
      SWIG_fail;
4886
5168
    }
4919
5201
  
4920
5202
  if (!PyArg_ParseTuple(args,(char *)"Oz:svn_fs_access_add_lock_token",&obj0,&arg2)) SWIG_fail;
4921
5203
  {
4922
 
    arg1 = (svn_fs_access_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_access_t, svn_argnum_obj0);
 
5204
    arg1 = (svn_fs_access_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_access_t, svn_argnum_obj0);
4923
5205
    if (PyErr_Occurred()) {
4924
5206
      SWIG_fail;
4925
5207
    }
4959
5241
  
4960
5242
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_compare_ids",&obj0,&obj1)) SWIG_fail;
4961
5243
  {
4962
 
    arg1 = (svn_fs_id_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj0);
 
5244
    arg1 = (svn_fs_id_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj0);
4963
5245
    if (PyErr_Occurred()) {
4964
5246
      SWIG_fail;
4965
5247
    }
4966
5248
  }
4967
5249
  {
4968
 
    arg2 = (svn_fs_id_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj1);
 
5250
    arg2 = (svn_fs_id_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj1);
4969
5251
    if (PyErr_Occurred()) {
4970
5252
      SWIG_fail;
4971
5253
    }
4995
5277
  
4996
5278
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_check_related",&obj0,&obj1)) SWIG_fail;
4997
5279
  {
4998
 
    arg1 = (svn_fs_id_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj0);
 
5280
    arg1 = (svn_fs_id_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj0);
4999
5281
    if (PyErr_Occurred()) {
5000
5282
      SWIG_fail;
5001
5283
    }
5002
5284
  }
5003
5285
  {
5004
 
    arg2 = (svn_fs_id_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj1);
 
5286
    arg2 = (svn_fs_id_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj1);
5005
5287
    if (PyErr_Occurred()) {
5006
5288
      SWIG_fail;
5007
5289
    }
5061
5343
    svn_swig_py_acquire_py_lock();
5062
5344
    
5063
5345
  }
5064
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_fs_id_t,
 
5346
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_fs_id_t,
5065
5347
    _global_py_pool, args);
5066
5348
  {
5067
5349
    Py_XDECREF(_global_py_pool);
5091
5373
  arg2 = _global_pool;
5092
5374
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_unparse_id",&obj0,&obj1)) SWIG_fail;
5093
5375
  {
5094
 
    arg1 = (svn_fs_id_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj0);
 
5376
    arg1 = (svn_fs_id_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj0);
5095
5377
    if (PyErr_Occurred()) {
5096
5378
      SWIG_fail;
5097
5379
    }
5150
5432
  arg1 = &temp1;
5151
5433
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_fs_begin_txn2",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5152
5434
  {
5153
 
    arg2 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
5435
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
5154
5436
    if (PyErr_Occurred()) {
5155
5437
      SWIG_fail;
5156
5438
    }
5195
5477
    resultobj = Py_None;
5196
5478
  }
5197
5479
  {
5198
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
 
5480
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
5199
5481
        _global_py_pool, args))
5200
5482
    
5201
5483
    ;
5233
5515
  arg1 = &temp1;
5234
5516
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_fs_begin_txn",&obj0,&obj1,&obj2)) SWIG_fail;
5235
5517
  {
5236
 
    arg2 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
5518
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
5237
5519
    if (PyErr_Occurred()) {
5238
5520
      SWIG_fail;
5239
5521
    }
5272
5554
    resultobj = Py_None;
5273
5555
  }
5274
5556
  {
5275
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
 
5557
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
5276
5558
        _global_py_pool, args))
5277
5559
    
5278
5560
    ;
5312
5594
  arg2 = &temp2;
5313
5595
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_commit_txn",&obj0,&obj1)) SWIG_fail;
5314
5596
  {
5315
 
    arg3 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
 
5597
    arg3 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
5316
5598
    if (PyErr_Occurred()) {
5317
5599
      SWIG_fail;
5318
5600
    }
5378
5660
  arg2 = _global_pool;
5379
5661
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_abort_txn",&obj0,&obj1)) SWIG_fail;
5380
5662
  {
5381
 
    arg1 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
 
5663
    arg1 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
5382
5664
    if (PyErr_Occurred()) {
5383
5665
      SWIG_fail;
5384
5666
    }
5439
5721
  arg3 = _global_pool;
5440
5722
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_purge_txn",&obj0,&arg2,&obj2)) SWIG_fail;
5441
5723
  {
5442
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
5724
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
5443
5725
    if (PyErr_Occurred()) {
5444
5726
      SWIG_fail;
5445
5727
    }
5502
5784
  arg1 = &temp1;
5503
5785
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_txn_name",&obj0,&obj1)) SWIG_fail;
5504
5786
  {
5505
 
    arg2 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
 
5787
    arg2 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
5506
5788
    if (PyErr_Occurred()) {
5507
5789
      SWIG_fail;
5508
5790
    }
5567
5849
  
5568
5850
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_txn_base_revision",&obj0)) SWIG_fail;
5569
5851
  {
5570
 
    arg1 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
 
5852
    arg1 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
5571
5853
    if (PyErr_Occurred()) {
5572
5854
      SWIG_fail;
5573
5855
    }
5607
5889
  arg1 = &temp1;
5608
5890
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_open_txn",&obj0,&arg3,&obj2)) SWIG_fail;
5609
5891
  {
5610
 
    arg2 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
5892
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
5611
5893
    if (PyErr_Occurred()) {
5612
5894
      SWIG_fail;
5613
5895
    }
5640
5922
    resultobj = Py_None;
5641
5923
  }
5642
5924
  {
5643
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
 
5925
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_txn_t,
5644
5926
        _global_py_pool, args))
5645
5927
    
5646
5928
    ;
5676
5958
  arg1 = &temp1;
5677
5959
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_list_transactions",&obj0,&obj1)) SWIG_fail;
5678
5960
  {
5679
 
    arg2 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
5961
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
5680
5962
    if (PyErr_Occurred()) {
5681
5963
      SWIG_fail;
5682
5964
    }
5743
6025
  arg1 = &temp1;
5744
6026
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_txn_prop",&obj0,&arg3,&obj2)) SWIG_fail;
5745
6027
  {
5746
 
    arg2 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
 
6028
    arg2 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
5747
6029
    if (PyErr_Occurred()) {
5748
6030
      SWIG_fail;
5749
6031
    }
5819
6101
  arg1 = &temp1;
5820
6102
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_txn_proplist",&obj0,&obj1)) SWIG_fail;
5821
6103
  {
5822
 
    arg2 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
 
6104
    arg2 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
5823
6105
    if (PyErr_Occurred()) {
5824
6106
      SWIG_fail;
5825
6107
    }
5886
6168
  arg4 = _global_pool;
5887
6169
  if (!PyArg_ParseTuple(args,(char *)"OsO|O:svn_fs_change_txn_prop",&obj0,&arg2,&obj2,&obj3)) SWIG_fail;
5888
6170
  {
5889
 
    arg1 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
 
6171
    arg1 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
5890
6172
    if (PyErr_Occurred()) {
5891
6173
      SWIG_fail;
5892
6174
    }
5961
6243
  arg3 = _global_pool;
5962
6244
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_fs_change_txn_props",&obj0,&obj1,&obj2)) SWIG_fail;
5963
6245
  {
5964
 
    arg1 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
 
6246
    arg1 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
5965
6247
    if (PyErr_Occurred()) {
5966
6248
      SWIG_fail;
5967
6249
    }
5968
6250
  }
5969
6251
  {
5970
 
    arg2 = (apr_array_header_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
 
6252
    arg2 = (apr_array_header_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_array_header_t, svn_argnum_obj1);
5971
6253
    if (PyErr_Occurred()) {
5972
6254
      SWIG_fail;
5973
6255
    }
6032
6314
  arg1 = &temp1;
6033
6315
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_fs_revision_root",&obj0,&obj1,&obj2)) SWIG_fail;
6034
6316
  {
6035
 
    arg2 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
6317
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
6036
6318
    if (PyErr_Occurred()) {
6037
6319
      SWIG_fail;
6038
6320
    }
6071
6353
    resultobj = Py_None;
6072
6354
  }
6073
6355
  {
6074
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_root_t,
 
6356
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_root_t,
6075
6357
        _global_py_pool, args))
6076
6358
    
6077
6359
    ;
6107
6389
  arg1 = &temp1;
6108
6390
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_txn_root",&obj0,&obj1)) SWIG_fail;
6109
6391
  {
6110
 
    arg2 = (svn_fs_txn_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
 
6392
    arg2 = (svn_fs_txn_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_txn_t, svn_argnum_obj0);
6111
6393
    if (PyErr_Occurred()) {
6112
6394
      SWIG_fail;
6113
6395
    }
6140
6422
    resultobj = Py_None;
6141
6423
  }
6142
6424
  {
6143
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_root_t,
 
6425
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_root_t,
6144
6426
        _global_py_pool, args))
6145
6427
    
6146
6428
    ;
6164
6446
  
6165
6447
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_close_root",&obj0)) SWIG_fail;
6166
6448
  {
6167
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
6449
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
6168
6450
    if (PyErr_Occurred()) {
6169
6451
      SWIG_fail;
6170
6452
    }
6192
6474
  
6193
6475
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_root_fs",&obj0)) SWIG_fail;
6194
6476
  {
6195
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
6477
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
6196
6478
    if (PyErr_Occurred()) {
6197
6479
      SWIG_fail;
6198
6480
    }
6205
6487
    svn_swig_py_acquire_py_lock();
6206
6488
    
6207
6489
  }
6208
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_fs_t,
 
6490
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_fs_t,
6209
6491
    _global_py_pool, args);
6210
6492
  return resultobj;
6211
6493
fail:
6221
6503
  
6222
6504
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_is_txn_root",&obj0)) SWIG_fail;
6223
6505
  {
6224
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
6506
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
6225
6507
    if (PyErr_Occurred()) {
6226
6508
      SWIG_fail;
6227
6509
    }
6249
6531
  
6250
6532
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_is_revision_root",&obj0)) SWIG_fail;
6251
6533
  {
6252
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
6534
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
6253
6535
    if (PyErr_Occurred()) {
6254
6536
      SWIG_fail;
6255
6537
    }
6285
6567
  arg2 = _global_pool;
6286
6568
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_txn_root_name",&obj0,&obj1)) SWIG_fail;
6287
6569
  {
6288
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
6570
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
6289
6571
    if (PyErr_Occurred()) {
6290
6572
      SWIG_fail;
6291
6573
    }
6327
6609
  
6328
6610
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_txn_root_base_revision",&obj0)) SWIG_fail;
6329
6611
  {
6330
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
6612
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
6331
6613
    if (PyErr_Occurred()) {
6332
6614
      SWIG_fail;
6333
6615
    }
6355
6637
  
6356
6638
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_revision_root_revision",&obj0)) SWIG_fail;
6357
6639
  {
6358
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
6640
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
6359
6641
    if (PyErr_Occurred()) {
6360
6642
      SWIG_fail;
6361
6643
    }
6384
6666
  
6385
6667
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_path_change2_t_node_rev_id_set",&obj0,&obj1)) SWIG_fail;
6386
6668
  {
6387
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6669
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6388
6670
    if (PyErr_Occurred()) {
6389
6671
      SWIG_fail;
6390
6672
    }
6391
6673
  }
6392
6674
  {
6393
 
    arg2 = (svn_fs_id_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj1);
 
6675
    arg2 = (svn_fs_id_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj1);
6394
6676
    if (PyErr_Occurred()) {
6395
6677
      SWIG_fail;
6396
6678
    }
6411
6693
  
6412
6694
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change2_t_node_rev_id_get",&obj0)) SWIG_fail;
6413
6695
  {
6414
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6696
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6415
6697
    if (PyErr_Occurred()) {
6416
6698
      SWIG_fail;
6417
6699
    }
6418
6700
  }
6419
6701
  result = (svn_fs_id_t *) ((arg1)->node_rev_id);
6420
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_fs_id_t,
 
6702
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_fs_id_t,
6421
6703
    _global_py_pool, args);
6422
6704
  return resultobj;
6423
6705
fail:
6434
6716
  
6435
6717
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_path_change2_t_change_kind_set",&obj0,&obj1)) SWIG_fail;
6436
6718
  {
6437
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6719
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6438
6720
    if (PyErr_Occurred()) {
6439
6721
      SWIG_fail;
6440
6722
    }
6461
6743
  
6462
6744
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change2_t_change_kind_get",&obj0)) SWIG_fail;
6463
6745
  {
6464
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6746
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6465
6747
    if (PyErr_Occurred()) {
6466
6748
      SWIG_fail;
6467
6749
    }
6483
6765
  
6484
6766
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_path_change2_t_text_mod_set",&obj0,&obj1)) SWIG_fail;
6485
6767
  {
6486
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6768
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6487
6769
    if (PyErr_Occurred()) {
6488
6770
      SWIG_fail;
6489
6771
    }
6510
6792
  
6511
6793
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change2_t_text_mod_get",&obj0)) SWIG_fail;
6512
6794
  {
6513
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6795
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6514
6796
    if (PyErr_Occurred()) {
6515
6797
      SWIG_fail;
6516
6798
    }
6532
6814
  
6533
6815
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_path_change2_t_prop_mod_set",&obj0,&obj1)) SWIG_fail;
6534
6816
  {
6535
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6817
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6536
6818
    if (PyErr_Occurred()) {
6537
6819
      SWIG_fail;
6538
6820
    }
6559
6841
  
6560
6842
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change2_t_prop_mod_get",&obj0)) SWIG_fail;
6561
6843
  {
6562
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6844
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6563
6845
    if (PyErr_Occurred()) {
6564
6846
      SWIG_fail;
6565
6847
    }
6581
6863
  
6582
6864
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_path_change2_t_node_kind_set",&obj0,&obj1)) SWIG_fail;
6583
6865
  {
6584
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6866
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6585
6867
    if (PyErr_Occurred()) {
6586
6868
      SWIG_fail;
6587
6869
    }
6608
6890
  
6609
6891
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change2_t_node_kind_get",&obj0)) SWIG_fail;
6610
6892
  {
6611
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6893
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6612
6894
    if (PyErr_Occurred()) {
6613
6895
      SWIG_fail;
6614
6896
    }
6630
6912
  
6631
6913
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_path_change2_t_copyfrom_known_set",&obj0,&obj1)) SWIG_fail;
6632
6914
  {
6633
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6915
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6634
6916
    if (PyErr_Occurred()) {
6635
6917
      SWIG_fail;
6636
6918
    }
6657
6939
  
6658
6940
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change2_t_copyfrom_known_get",&obj0)) SWIG_fail;
6659
6941
  {
6660
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6942
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6661
6943
    if (PyErr_Occurred()) {
6662
6944
      SWIG_fail;
6663
6945
    }
6679
6961
  
6680
6962
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_path_change2_t_copyfrom_rev_set",&obj0,&obj1)) SWIG_fail;
6681
6963
  {
6682
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6964
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6683
6965
    if (PyErr_Occurred()) {
6684
6966
      SWIG_fail;
6685
6967
    }
6706
6988
  
6707
6989
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change2_t_copyfrom_rev_get",&obj0)) SWIG_fail;
6708
6990
  {
6709
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
6991
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6710
6992
    if (PyErr_Occurred()) {
6711
6993
      SWIG_fail;
6712
6994
    }
6727
7009
  
6728
7010
  if (!PyArg_ParseTuple(args,(char *)"Oz:svn_fs_path_change2_t_copyfrom_path_set",&obj0,&arg2)) SWIG_fail;
6729
7011
  {
6730
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
7012
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6731
7013
    if (PyErr_Occurred()) {
6732
7014
      SWIG_fail;
6733
7015
    }
6755
7037
  
6756
7038
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change2_t_copyfrom_path_get",&obj0)) SWIG_fail;
6757
7039
  {
6758
 
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
7040
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
6759
7041
    if (PyErr_Occurred()) {
6760
7042
      SWIG_fail;
6761
7043
    }
6768
7050
}
6769
7051
 
6770
7052
 
 
7053
SWIGINTERN PyObject *_wrap_svn_fs_path_change2_t_mergeinfo_mod_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7054
  PyObject *resultobj = 0;
 
7055
  struct svn_fs_path_change2_t *arg1 = (struct svn_fs_path_change2_t *) 0 ;
 
7056
  svn_tristate_t arg2 ;
 
7057
  PyObject * obj0 = 0 ;
 
7058
  PyObject * obj1 = 0 ;
 
7059
  
 
7060
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_path_change2_t_mergeinfo_mod_set",&obj0,&obj1)) SWIG_fail;
 
7061
  {
 
7062
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
7063
    if (PyErr_Occurred()) {
 
7064
      SWIG_fail;
 
7065
    }
 
7066
  }
 
7067
  {
 
7068
    arg2 = (svn_tristate_t)SWIG_As_long (obj1);
 
7069
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
7070
      SWIG_fail;
 
7071
    }
 
7072
  }
 
7073
  if (arg1) (arg1)->mergeinfo_mod = arg2;
 
7074
  resultobj = SWIG_Py_Void();
 
7075
  return resultobj;
 
7076
fail:
 
7077
  return NULL;
 
7078
}
 
7079
 
 
7080
 
 
7081
SWIGINTERN PyObject *_wrap_svn_fs_path_change2_t_mergeinfo_mod_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7082
  PyObject *resultobj = 0;
 
7083
  struct svn_fs_path_change2_t *arg1 = (struct svn_fs_path_change2_t *) 0 ;
 
7084
  PyObject * obj0 = 0 ;
 
7085
  svn_tristate_t result;
 
7086
  
 
7087
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change2_t_mergeinfo_mod_get",&obj0)) SWIG_fail;
 
7088
  {
 
7089
    arg1 = (struct svn_fs_path_change2_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change2_t, svn_argnum_obj0);
 
7090
    if (PyErr_Occurred()) {
 
7091
      SWIG_fail;
 
7092
    }
 
7093
  }
 
7094
  result = (svn_tristate_t) ((arg1)->mergeinfo_mod);
 
7095
  resultobj = SWIG_From_long((long)(result));
 
7096
  return resultobj;
 
7097
fail:
 
7098
  return NULL;
 
7099
}
 
7100
 
 
7101
 
6771
7102
SWIGINTERN PyObject *svn_fs_path_change2_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6772
7103
  PyObject *obj;
6773
7104
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
6784
7115
  
6785
7116
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_path_change_t_node_rev_id_set",&obj0,&obj1)) SWIG_fail;
6786
7117
  {
6787
 
    arg1 = (struct svn_fs_path_change_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
 
7118
    arg1 = (struct svn_fs_path_change_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
6788
7119
    if (PyErr_Occurred()) {
6789
7120
      SWIG_fail;
6790
7121
    }
6791
7122
  }
6792
7123
  {
6793
 
    arg2 = (svn_fs_id_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj1);
 
7124
    arg2 = (svn_fs_id_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj1);
6794
7125
    if (PyErr_Occurred()) {
6795
7126
      SWIG_fail;
6796
7127
    }
6811
7142
  
6812
7143
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change_t_node_rev_id_get",&obj0)) SWIG_fail;
6813
7144
  {
6814
 
    arg1 = (struct svn_fs_path_change_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
 
7145
    arg1 = (struct svn_fs_path_change_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
6815
7146
    if (PyErr_Occurred()) {
6816
7147
      SWIG_fail;
6817
7148
    }
6818
7149
  }
6819
7150
  result = (svn_fs_id_t *) ((arg1)->node_rev_id);
6820
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_fs_id_t,
 
7151
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_fs_id_t,
6821
7152
    _global_py_pool, args);
6822
7153
  return resultobj;
6823
7154
fail:
6834
7165
  
6835
7166
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_path_change_t_change_kind_set",&obj0,&obj1)) SWIG_fail;
6836
7167
  {
6837
 
    arg1 = (struct svn_fs_path_change_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
 
7168
    arg1 = (struct svn_fs_path_change_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
6838
7169
    if (PyErr_Occurred()) {
6839
7170
      SWIG_fail;
6840
7171
    }
6861
7192
  
6862
7193
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change_t_change_kind_get",&obj0)) SWIG_fail;
6863
7194
  {
6864
 
    arg1 = (struct svn_fs_path_change_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
 
7195
    arg1 = (struct svn_fs_path_change_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
6865
7196
    if (PyErr_Occurred()) {
6866
7197
      SWIG_fail;
6867
7198
    }
6883
7214
  
6884
7215
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_path_change_t_text_mod_set",&obj0,&obj1)) SWIG_fail;
6885
7216
  {
6886
 
    arg1 = (struct svn_fs_path_change_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
 
7217
    arg1 = (struct svn_fs_path_change_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
6887
7218
    if (PyErr_Occurred()) {
6888
7219
      SWIG_fail;
6889
7220
    }
6910
7241
  
6911
7242
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change_t_text_mod_get",&obj0)) SWIG_fail;
6912
7243
  {
6913
 
    arg1 = (struct svn_fs_path_change_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
 
7244
    arg1 = (struct svn_fs_path_change_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
6914
7245
    if (PyErr_Occurred()) {
6915
7246
      SWIG_fail;
6916
7247
    }
6932
7263
  
6933
7264
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_path_change_t_prop_mod_set",&obj0,&obj1)) SWIG_fail;
6934
7265
  {
6935
 
    arg1 = (struct svn_fs_path_change_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
 
7266
    arg1 = (struct svn_fs_path_change_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
6936
7267
    if (PyErr_Occurred()) {
6937
7268
      SWIG_fail;
6938
7269
    }
6959
7290
  
6960
7291
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_path_change_t_prop_mod_get",&obj0)) SWIG_fail;
6961
7292
  {
6962
 
    arg1 = (struct svn_fs_path_change_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
 
7293
    arg1 = (struct svn_fs_path_change_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_path_change_t, svn_argnum_obj0);
6963
7294
    if (PyErr_Occurred()) {
6964
7295
      SWIG_fail;
6965
7296
    }
6997
7328
  arg3 = _global_pool;
6998
7329
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_fs_path_change2_create",&obj0,&obj1,&obj2)) SWIG_fail;
6999
7330
  {
7000
 
    arg1 = (svn_fs_id_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj0);
 
7331
    arg1 = (svn_fs_id_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj0);
7001
7332
    if (PyErr_Occurred()) {
7002
7333
      SWIG_fail;
7003
7334
    }
7024
7355
    svn_swig_py_acquire_py_lock();
7025
7356
    
7026
7357
  }
7027
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_fs_path_change2_t,
 
7358
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_fs_path_change2_t,
7028
7359
    _global_py_pool, args);
7029
7360
  {
7030
7361
    Py_XDECREF(_global_py_pool);
7057
7388
  arg1 = &temp1;
7058
7389
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_paths_changed2",&obj0,&obj1)) SWIG_fail;
7059
7390
  {
7060
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
7391
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7061
7392
    if (PyErr_Occurred()) {
7062
7393
      SWIG_fail;
7063
7394
    }
7129
7460
  arg1 = &temp1;
7130
7461
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_paths_changed",&obj0,&obj1)) SWIG_fail;
7131
7462
  {
7132
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
7463
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7133
7464
    if (PyErr_Occurred()) {
7134
7465
      SWIG_fail;
7135
7466
    }
7203
7534
  arg1 = &temp1;
7204
7535
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_check_path",&obj0,&arg3,&obj2)) SWIG_fail;
7205
7536
  {
7206
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
7537
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7207
7538
    if (PyErr_Occurred()) {
7208
7539
      SWIG_fail;
7209
7540
    }
7253
7584
}
7254
7585
 
7255
7586
 
 
7587
SWIGINTERN PyObject *_wrap_svn_fs_node_history2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7588
  PyObject *resultobj = 0;
 
7589
  svn_fs_history_t **arg1 = (svn_fs_history_t **) 0 ;
 
7590
  svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
7591
  char *arg3 = (char *) 0 ;
 
7592
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
7593
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
7594
  apr_pool_t *_global_pool = NULL ;
 
7595
  PyObject *_global_py_pool = NULL ;
 
7596
  svn_fs_history_t *temp1 ;
 
7597
  PyObject * obj0 = 0 ;
 
7598
  PyObject * obj2 = 0 ;
 
7599
  PyObject * obj3 = 0 ;
 
7600
  svn_error_t *result = 0 ;
 
7601
  
 
7602
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
7603
      &_global_py_pool, &_global_pool))
 
7604
  SWIG_fail;
 
7605
  arg4 = _global_pool;
 
7606
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
7607
      &_global_py_pool, &_global_pool))
 
7608
  SWIG_fail;
 
7609
  arg5 = _global_pool;
 
7610
  arg1 = &temp1;
 
7611
  if (!PyArg_ParseTuple(args,(char *)"Os|OO:svn_fs_node_history2",&obj0,&arg3,&obj2,&obj3)) SWIG_fail;
 
7612
  {
 
7613
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
7614
    if (PyErr_Occurred()) {
 
7615
      SWIG_fail;
 
7616
    }
 
7617
  }
 
7618
  if (obj2) {
 
7619
    /* Verify that the user supplied a valid pool */
 
7620
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
7621
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
7622
      SWIG_arg_fail(svn_argnum_obj2);
 
7623
      SWIG_fail;
 
7624
    }
 
7625
  }
 
7626
  if (obj3) {
 
7627
    /* Verify that the user supplied a valid pool */
 
7628
    if (obj3 != Py_None && obj3 != _global_py_pool) {
 
7629
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
 
7630
      SWIG_arg_fail(svn_argnum_obj3);
 
7631
      SWIG_fail;
 
7632
    }
 
7633
  }
 
7634
  {
 
7635
    svn_swig_py_release_py_lock();
 
7636
    
 
7637
    result = (svn_error_t *)svn_fs_node_history2(arg1,arg2,(char const *)arg3,arg4,arg5);
 
7638
    
 
7639
    svn_swig_py_acquire_py_lock();
 
7640
    
 
7641
  }
 
7642
  {
 
7643
    if (result != NULL) {
 
7644
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
7645
      svn_swig_py_svn_exception(result);
 
7646
      else
 
7647
      svn_error_clear(result);
 
7648
      SWIG_fail;
 
7649
    }
 
7650
    Py_INCREF(Py_None);
 
7651
    resultobj = Py_None;
 
7652
  }
 
7653
  {
 
7654
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_history_t,
 
7655
        _global_py_pool, args))
 
7656
    
 
7657
    ;
 
7658
  }
 
7659
  {
 
7660
    Py_XDECREF(_global_py_pool);
 
7661
  }
 
7662
  {
 
7663
    Py_XDECREF(_global_py_pool);
 
7664
  }
 
7665
  return resultobj;
 
7666
fail:
 
7667
  {
 
7668
    Py_XDECREF(_global_py_pool);
 
7669
  }
 
7670
  {
 
7671
    Py_XDECREF(_global_py_pool);
 
7672
  }
 
7673
  return NULL;
 
7674
}
 
7675
 
 
7676
 
7256
7677
SWIGINTERN PyObject *_wrap_svn_fs_node_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7257
7678
  PyObject *resultobj = 0;
7258
7679
  svn_fs_history_t **arg1 = (svn_fs_history_t **) 0 ;
7273
7694
  arg1 = &temp1;
7274
7695
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_node_history",&obj0,&arg3,&obj2)) SWIG_fail;
7275
7696
  {
7276
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
7697
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7277
7698
    if (PyErr_Occurred()) {
7278
7699
      SWIG_fail;
7279
7700
    }
7306
7727
    resultobj = Py_None;
7307
7728
  }
7308
7729
  {
7309
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_history_t,
7310
 
        _global_py_pool, args))
7311
 
    
7312
 
    ;
7313
 
  }
7314
 
  {
7315
 
    Py_XDECREF(_global_py_pool);
7316
 
  }
7317
 
  return resultobj;
7318
 
fail:
 
7730
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_history_t,
 
7731
        _global_py_pool, args))
 
7732
    
 
7733
    ;
 
7734
  }
 
7735
  {
 
7736
    Py_XDECREF(_global_py_pool);
 
7737
  }
 
7738
  return resultobj;
 
7739
fail:
 
7740
  {
 
7741
    Py_XDECREF(_global_py_pool);
 
7742
  }
 
7743
  return NULL;
 
7744
}
 
7745
 
 
7746
 
 
7747
SWIGINTERN PyObject *_wrap_svn_fs_history_prev2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7748
  PyObject *resultobj = 0;
 
7749
  svn_fs_history_t **arg1 = (svn_fs_history_t **) 0 ;
 
7750
  svn_fs_history_t *arg2 = (svn_fs_history_t *) 0 ;
 
7751
  svn_boolean_t arg3 ;
 
7752
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
7753
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
7754
  apr_pool_t *_global_pool = NULL ;
 
7755
  PyObject *_global_py_pool = NULL ;
 
7756
  svn_fs_history_t *temp1 ;
 
7757
  PyObject * obj0 = 0 ;
 
7758
  PyObject * obj1 = 0 ;
 
7759
  PyObject * obj2 = 0 ;
 
7760
  PyObject * obj3 = 0 ;
 
7761
  svn_error_t *result = 0 ;
 
7762
  
 
7763
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
7764
      &_global_py_pool, &_global_pool))
 
7765
  SWIG_fail;
 
7766
  arg4 = _global_pool;
 
7767
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
7768
      &_global_py_pool, &_global_pool))
 
7769
  SWIG_fail;
 
7770
  arg5 = _global_pool;
 
7771
  arg1 = &temp1;
 
7772
  if (!PyArg_ParseTuple(args,(char *)"OO|OO:svn_fs_history_prev2",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
7773
  {
 
7774
    arg2 = (svn_fs_history_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_history_t, svn_argnum_obj0);
 
7775
    if (PyErr_Occurred()) {
 
7776
      SWIG_fail;
 
7777
    }
 
7778
  }
 
7779
  {
 
7780
    arg3 = (svn_boolean_t)SWIG_As_long (obj1);
 
7781
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
7782
      SWIG_fail;
 
7783
    }
 
7784
  }
 
7785
  if (obj2) {
 
7786
    /* Verify that the user supplied a valid pool */
 
7787
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
7788
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
7789
      SWIG_arg_fail(svn_argnum_obj2);
 
7790
      SWIG_fail;
 
7791
    }
 
7792
  }
 
7793
  if (obj3) {
 
7794
    /* Verify that the user supplied a valid pool */
 
7795
    if (obj3 != Py_None && obj3 != _global_py_pool) {
 
7796
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
 
7797
      SWIG_arg_fail(svn_argnum_obj3);
 
7798
      SWIG_fail;
 
7799
    }
 
7800
  }
 
7801
  {
 
7802
    svn_swig_py_release_py_lock();
 
7803
    
 
7804
    result = (svn_error_t *)svn_fs_history_prev2(arg1,arg2,arg3,arg4,arg5);
 
7805
    
 
7806
    svn_swig_py_acquire_py_lock();
 
7807
    
 
7808
  }
 
7809
  {
 
7810
    if (result != NULL) {
 
7811
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
7812
      svn_swig_py_svn_exception(result);
 
7813
      else
 
7814
      svn_error_clear(result);
 
7815
      SWIG_fail;
 
7816
    }
 
7817
    Py_INCREF(Py_None);
 
7818
    resultobj = Py_None;
 
7819
  }
 
7820
  {
 
7821
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_history_t,
 
7822
        _global_py_pool, args))
 
7823
    
 
7824
    ;
 
7825
  }
 
7826
  {
 
7827
    Py_XDECREF(_global_py_pool);
 
7828
  }
 
7829
  {
 
7830
    Py_XDECREF(_global_py_pool);
 
7831
  }
 
7832
  return resultobj;
 
7833
fail:
 
7834
  {
 
7835
    Py_XDECREF(_global_py_pool);
 
7836
  }
7319
7837
  {
7320
7838
    Py_XDECREF(_global_py_pool);
7321
7839
  }
7344
7862
  arg1 = &temp1;
7345
7863
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_fs_history_prev",&obj0,&obj1,&obj2)) SWIG_fail;
7346
7864
  {
7347
 
    arg2 = (svn_fs_history_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_history_t, svn_argnum_obj0);
 
7865
    arg2 = (svn_fs_history_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_history_t, svn_argnum_obj0);
7348
7866
    if (PyErr_Occurred()) {
7349
7867
      SWIG_fail;
7350
7868
    }
7383
7901
    resultobj = Py_None;
7384
7902
  }
7385
7903
  {
7386
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_history_t,
 
7904
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_history_t,
7387
7905
        _global_py_pool, args))
7388
7906
    
7389
7907
    ;
7423
7941
  arg2 = &temp2;
7424
7942
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_history_location",&obj0,&obj1)) SWIG_fail;
7425
7943
  {
7426
 
    arg3 = (svn_fs_history_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_history_t, svn_argnum_obj0);
 
7944
    arg3 = (svn_fs_history_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_history_t, svn_argnum_obj0);
7427
7945
    if (PyErr_Occurred()) {
7428
7946
      SWIG_fail;
7429
7947
    }
7507
8025
  arg1 = &temp1;
7508
8026
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_is_dir",&obj0,&arg3,&obj2)) SWIG_fail;
7509
8027
  {
7510
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8028
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7511
8029
    if (PyErr_Occurred()) {
7512
8030
      SWIG_fail;
7513
8031
    }
7578
8096
  arg1 = &temp1;
7579
8097
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_is_file",&obj0,&arg3,&obj2)) SWIG_fail;
7580
8098
  {
7581
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8099
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7582
8100
    if (PyErr_Occurred()) {
7583
8101
      SWIG_fail;
7584
8102
    }
7648
8166
  arg1 = &temp1;
7649
8167
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_node_id",&obj0,&arg3,&obj2)) SWIG_fail;
7650
8168
  {
7651
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8169
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7652
8170
    if (PyErr_Occurred()) {
7653
8171
      SWIG_fail;
7654
8172
    }
7681
8199
    resultobj = Py_None;
7682
8200
  }
7683
8201
  {
7684
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_id_t,
 
8202
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_id_t,
7685
8203
        _global_py_pool, args))
7686
8204
    
7687
8205
    ;
7698
8216
}
7699
8217
 
7700
8218
 
 
8219
SWIGINTERN PyObject *_wrap_svn_fs_node_relation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8220
  PyObject *resultobj = 0;
 
8221
  svn_fs_node_relation_t *arg1 = (svn_fs_node_relation_t *) 0 ;
 
8222
  svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
8223
  char *arg3 = (char *) 0 ;
 
8224
  svn_fs_root_t *arg4 = (svn_fs_root_t *) 0 ;
 
8225
  char *arg5 = (char *) 0 ;
 
8226
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
8227
  apr_pool_t *_global_pool = NULL ;
 
8228
  PyObject *_global_py_pool = NULL ;
 
8229
  PyObject * obj0 = 0 ;
 
8230
  PyObject * obj1 = 0 ;
 
8231
  PyObject * obj3 = 0 ;
 
8232
  PyObject * obj5 = 0 ;
 
8233
  svn_error_t *result = 0 ;
 
8234
  
 
8235
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
8236
      &_global_py_pool, &_global_pool))
 
8237
  SWIG_fail;
 
8238
  arg6 = _global_pool;
 
8239
  if (!PyArg_ParseTuple(args,(char *)"OOsOs|O:svn_fs_node_relation",&obj0,&obj1,&arg3,&obj3,&arg5,&obj5)) SWIG_fail;
 
8240
  {
 
8241
    arg1 = (svn_fs_node_relation_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_node_relation_t, svn_argnum_obj0);
 
8242
    if (PyErr_Occurred()) {
 
8243
      SWIG_fail;
 
8244
    }
 
8245
  }
 
8246
  {
 
8247
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj1);
 
8248
    if (PyErr_Occurred()) {
 
8249
      SWIG_fail;
 
8250
    }
 
8251
  }
 
8252
  {
 
8253
    arg4 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj3);
 
8254
    if (PyErr_Occurred()) {
 
8255
      SWIG_fail;
 
8256
    }
 
8257
  }
 
8258
  if (obj5) {
 
8259
    /* Verify that the user supplied a valid pool */
 
8260
    if (obj5 != Py_None && obj5 != _global_py_pool) {
 
8261
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
 
8262
      SWIG_arg_fail(svn_argnum_obj5);
 
8263
      SWIG_fail;
 
8264
    }
 
8265
  }
 
8266
  {
 
8267
    svn_swig_py_release_py_lock();
 
8268
    
 
8269
    result = (svn_error_t *)svn_fs_node_relation(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,arg6);
 
8270
    
 
8271
    svn_swig_py_acquire_py_lock();
 
8272
    
 
8273
  }
 
8274
  {
 
8275
    if (result != NULL) {
 
8276
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
8277
      svn_swig_py_svn_exception(result);
 
8278
      else
 
8279
      svn_error_clear(result);
 
8280
      SWIG_fail;
 
8281
    }
 
8282
    Py_INCREF(Py_None);
 
8283
    resultobj = Py_None;
 
8284
  }
 
8285
  {
 
8286
    Py_XDECREF(_global_py_pool);
 
8287
  }
 
8288
  return resultobj;
 
8289
fail:
 
8290
  {
 
8291
    Py_XDECREF(_global_py_pool);
 
8292
  }
 
8293
  return NULL;
 
8294
}
 
8295
 
 
8296
 
7701
8297
SWIGINTERN PyObject *_wrap_svn_fs_node_created_rev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7702
8298
  PyObject *resultobj = 0;
7703
8299
  svn_revnum_t *arg1 = (svn_revnum_t *) 0 ;
7719
8315
  arg1 = &temp1;
7720
8316
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_node_created_rev",&obj0,&arg3,&obj2)) SWIG_fail;
7721
8317
  {
7722
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8318
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7723
8319
    if (PyErr_Occurred()) {
7724
8320
      SWIG_fail;
7725
8321
    }
7790
8386
  arg1 = &temp1;
7791
8387
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_node_origin_rev",&obj0,&arg3,&obj2)) SWIG_fail;
7792
8388
  {
7793
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8389
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7794
8390
    if (PyErr_Occurred()) {
7795
8391
      SWIG_fail;
7796
8392
    }
7860
8456
  arg1 = &temp1;
7861
8457
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_node_created_path",&obj0,&arg3,&obj2)) SWIG_fail;
7862
8458
  {
7863
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8459
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7864
8460
    if (PyErr_Occurred()) {
7865
8461
      SWIG_fail;
7866
8462
    }
7938
8534
  arg1 = &temp1;
7939
8535
  if (!PyArg_ParseTuple(args,(char *)"Oss|O:svn_fs_node_prop",&obj0,&arg3,&arg4,&obj3)) SWIG_fail;
7940
8536
  {
7941
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8537
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
7942
8538
    if (PyErr_Occurred()) {
7943
8539
      SWIG_fail;
7944
8540
    }
8015
8611
  arg1 = &temp1;
8016
8612
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_node_proplist",&obj0,&arg3,&obj2)) SWIG_fail;
8017
8613
  {
8018
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8614
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
8019
8615
    if (PyErr_Occurred()) {
8020
8616
      SWIG_fail;
8021
8617
    }
8062
8658
}
8063
8659
 
8064
8660
 
 
8661
SWIGINTERN PyObject *_wrap_svn_fs_node_has_props(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8662
  PyObject *resultobj = 0;
 
8663
  svn_boolean_t *arg1 = (svn_boolean_t *) 0 ;
 
8664
  svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
8665
  char *arg3 = (char *) 0 ;
 
8666
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
8667
  apr_pool_t *_global_pool = NULL ;
 
8668
  PyObject *_global_py_pool = NULL ;
 
8669
  svn_boolean_t temp1 ;
 
8670
  int res1 = SWIG_TMPOBJ ;
 
8671
  PyObject * obj0 = 0 ;
 
8672
  PyObject * obj2 = 0 ;
 
8673
  svn_error_t *result = 0 ;
 
8674
  
 
8675
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
8676
      &_global_py_pool, &_global_pool))
 
8677
  SWIG_fail;
 
8678
  arg4 = _global_pool;
 
8679
  arg1 = &temp1;
 
8680
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_node_has_props",&obj0,&arg3,&obj2)) SWIG_fail;
 
8681
  {
 
8682
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8683
    if (PyErr_Occurred()) {
 
8684
      SWIG_fail;
 
8685
    }
 
8686
  }
 
8687
  if (obj2) {
 
8688
    /* Verify that the user supplied a valid pool */
 
8689
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
8690
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
8691
      SWIG_arg_fail(svn_argnum_obj2);
 
8692
      SWIG_fail;
 
8693
    }
 
8694
  }
 
8695
  {
 
8696
    svn_swig_py_release_py_lock();
 
8697
    
 
8698
    result = (svn_error_t *)svn_fs_node_has_props(arg1,arg2,(char const *)arg3,arg4);
 
8699
    
 
8700
    svn_swig_py_acquire_py_lock();
 
8701
    
 
8702
  }
 
8703
  {
 
8704
    if (result != NULL) {
 
8705
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
8706
      svn_swig_py_svn_exception(result);
 
8707
      else
 
8708
      svn_error_clear(result);
 
8709
      SWIG_fail;
 
8710
    }
 
8711
    Py_INCREF(Py_None);
 
8712
    resultobj = Py_None;
 
8713
  }
 
8714
  if (SWIG_IsTmpObj(res1)) {
 
8715
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
 
8716
  } else {
 
8717
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
8718
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
 
8719
  }
 
8720
  {
 
8721
    Py_XDECREF(_global_py_pool);
 
8722
  }
 
8723
  return resultobj;
 
8724
fail:
 
8725
  {
 
8726
    Py_XDECREF(_global_py_pool);
 
8727
  }
 
8728
  return NULL;
 
8729
}
 
8730
 
 
8731
 
8065
8732
SWIGINTERN PyObject *_wrap_svn_fs_change_node_prop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8066
8733
  PyObject *resultobj = 0;
8067
8734
  svn_fs_root_t *arg1 = (svn_fs_root_t *) 0 ;
8083
8750
  arg5 = _global_pool;
8084
8751
  if (!PyArg_ParseTuple(args,(char *)"OssO|O:svn_fs_change_node_prop",&obj0,&arg2,&arg3,&obj3,&obj4)) SWIG_fail;
8085
8752
  {
8086
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8753
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
8087
8754
    if (PyErr_Occurred()) {
8088
8755
      SWIG_fail;
8089
8756
    }
8140
8807
}
8141
8808
 
8142
8809
 
 
8810
SWIGINTERN PyObject *_wrap_svn_fs_props_different(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8811
  PyObject *resultobj = 0;
 
8812
  svn_boolean_t *arg1 = (svn_boolean_t *) 0 ;
 
8813
  svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
8814
  char *arg3 = (char *) 0 ;
 
8815
  svn_fs_root_t *arg4 = (svn_fs_root_t *) 0 ;
 
8816
  char *arg5 = (char *) 0 ;
 
8817
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
8818
  apr_pool_t *_global_pool = NULL ;
 
8819
  PyObject *_global_py_pool = NULL ;
 
8820
  svn_boolean_t temp1 ;
 
8821
  int res1 = SWIG_TMPOBJ ;
 
8822
  PyObject * obj0 = 0 ;
 
8823
  PyObject * obj2 = 0 ;
 
8824
  PyObject * obj4 = 0 ;
 
8825
  svn_error_t *result = 0 ;
 
8826
  
 
8827
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
8828
      &_global_py_pool, &_global_pool))
 
8829
  SWIG_fail;
 
8830
  arg6 = _global_pool;
 
8831
  arg1 = &temp1;
 
8832
  if (!PyArg_ParseTuple(args,(char *)"OsOs|O:svn_fs_props_different",&obj0,&arg3,&obj2,&arg5,&obj4)) SWIG_fail;
 
8833
  {
 
8834
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8835
    if (PyErr_Occurred()) {
 
8836
      SWIG_fail;
 
8837
    }
 
8838
  }
 
8839
  {
 
8840
    arg4 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
 
8841
    if (PyErr_Occurred()) {
 
8842
      SWIG_fail;
 
8843
    }
 
8844
  }
 
8845
  if (obj4) {
 
8846
    /* Verify that the user supplied a valid pool */
 
8847
    if (obj4 != Py_None && obj4 != _global_py_pool) {
 
8848
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
 
8849
      SWIG_arg_fail(svn_argnum_obj4);
 
8850
      SWIG_fail;
 
8851
    }
 
8852
  }
 
8853
  {
 
8854
    svn_swig_py_release_py_lock();
 
8855
    
 
8856
    result = (svn_error_t *)svn_fs_props_different(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,arg6);
 
8857
    
 
8858
    svn_swig_py_acquire_py_lock();
 
8859
    
 
8860
  }
 
8861
  {
 
8862
    if (result != NULL) {
 
8863
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
8864
      svn_swig_py_svn_exception(result);
 
8865
      else
 
8866
      svn_error_clear(result);
 
8867
      SWIG_fail;
 
8868
    }
 
8869
    Py_INCREF(Py_None);
 
8870
    resultobj = Py_None;
 
8871
  }
 
8872
  if (SWIG_IsTmpObj(res1)) {
 
8873
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
 
8874
  } else {
 
8875
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
8876
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
 
8877
  }
 
8878
  {
 
8879
    Py_XDECREF(_global_py_pool);
 
8880
  }
 
8881
  return resultobj;
 
8882
fail:
 
8883
  {
 
8884
    Py_XDECREF(_global_py_pool);
 
8885
  }
 
8886
  return NULL;
 
8887
}
 
8888
 
 
8889
 
8143
8890
SWIGINTERN PyObject *_wrap_svn_fs_props_changed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8144
8891
  PyObject *resultobj = 0;
8145
8892
  svn_boolean_t *arg1 = (svn_boolean_t *) 0 ;
8164
8911
  arg1 = &temp1;
8165
8912
  if (!PyArg_ParseTuple(args,(char *)"OsOs|O:svn_fs_props_changed",&obj0,&arg3,&obj2,&arg5,&obj4)) SWIG_fail;
8166
8913
  {
8167
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8914
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
8168
8915
    if (PyErr_Occurred()) {
8169
8916
      SWIG_fail;
8170
8917
    }
8171
8918
  }
8172
8919
  {
8173
 
    arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
 
8920
    arg4 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
8174
8921
    if (PyErr_Occurred()) {
8175
8922
      SWIG_fail;
8176
8923
    }
8244
8991
  arg2 = &temp2;
8245
8992
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_copied_from",&obj0,&arg4,&obj2)) SWIG_fail;
8246
8993
  {
8247
 
    arg3 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
8994
    arg3 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
8248
8995
    if (PyErr_Occurred()) {
8249
8996
      SWIG_fail;
8250
8997
    }
8330
9077
  arg2 = &temp2;
8331
9078
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_closest_copy",&obj0,&arg4,&obj2)) SWIG_fail;
8332
9079
  {
8333
 
    arg3 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
9080
    arg3 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
8334
9081
    if (PyErr_Occurred()) {
8335
9082
      SWIG_fail;
8336
9083
    }
8363
9110
    resultobj = Py_None;
8364
9111
  }
8365
9112
  {
8366
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_fs_root_t,
 
9113
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_fs_root_t,
8367
9114
        _global_py_pool, args))
8368
9115
    
8369
9116
    ;
8426
9173
  arg1 = &temp1;
8427
9174
  if (!PyArg_ParseTuple(args,(char *)"OOOOO|OO:svn_fs_get_mergeinfo2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
8428
9175
  {
8429
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
9176
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
8430
9177
    if (PyErr_Occurred()) {
8431
9178
      SWIG_fail;
8432
9179
    }
8548
9295
  arg1 = &temp1;
8549
9296
  if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_fs_get_mergeinfo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8550
9297
  {
8551
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
9298
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
8552
9299
    if (PyErr_Occurred()) {
8553
9300
      SWIG_fail;
8554
9301
    }
8651
9398
  arg1 = &temp1;
8652
9399
  if (!PyArg_ParseTuple(args,(char *)"OsOsOs|O:svn_fs_merge",&obj0,&arg3,&obj2,&arg5,&obj4,&arg7,&obj6)) SWIG_fail;
8653
9400
  {
8654
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
8655
 
    if (PyErr_Occurred()) {
8656
 
      SWIG_fail;
8657
 
    }
8658
 
  }
8659
 
  {
8660
 
    arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
8661
 
    if (PyErr_Occurred()) {
8662
 
      SWIG_fail;
8663
 
    }
8664
 
  }
8665
 
  {
8666
 
    arg6 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj4, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj4);
 
9401
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
9402
    if (PyErr_Occurred()) {
 
9403
      SWIG_fail;
 
9404
    }
 
9405
  }
 
9406
  {
 
9407
    arg4 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
 
9408
    if (PyErr_Occurred()) {
 
9409
      SWIG_fail;
 
9410
    }
 
9411
  }
 
9412
  {
 
9413
    arg6 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj4);
8667
9414
    if (PyErr_Occurred()) {
8668
9415
      SWIG_fail;
8669
9416
    }
8728
9475
  
8729
9476
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_fs_dirent_t_name_set",&obj0,&arg2)) SWIG_fail;
8730
9477
  {
8731
 
    arg1 = (struct svn_fs_dirent_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_dirent_t, svn_argnum_obj0);
 
9478
    arg1 = (struct svn_fs_dirent_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_dirent_t, svn_argnum_obj0);
8732
9479
    if (PyErr_Occurred()) {
8733
9480
      SWIG_fail;
8734
9481
    }
8756
9503
  
8757
9504
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_dirent_t_name_get",&obj0)) SWIG_fail;
8758
9505
  {
8759
 
    arg1 = (struct svn_fs_dirent_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_dirent_t, svn_argnum_obj0);
 
9506
    arg1 = (struct svn_fs_dirent_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_dirent_t, svn_argnum_obj0);
8760
9507
    if (PyErr_Occurred()) {
8761
9508
      SWIG_fail;
8762
9509
    }
8778
9525
  
8779
9526
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_dirent_t_id_set",&obj0,&obj1)) SWIG_fail;
8780
9527
  {
8781
 
    arg1 = (struct svn_fs_dirent_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_dirent_t, svn_argnum_obj0);
 
9528
    arg1 = (struct svn_fs_dirent_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_dirent_t, svn_argnum_obj0);
8782
9529
    if (PyErr_Occurred()) {
8783
9530
      SWIG_fail;
8784
9531
    }
8785
9532
  }
8786
9533
  {
8787
 
    arg2 = (svn_fs_id_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj1);
 
9534
    arg2 = (svn_fs_id_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_id_t, svn_argnum_obj1);
8788
9535
    if (PyErr_Occurred()) {
8789
9536
      SWIG_fail;
8790
9537
    }
8805
9552
  
8806
9553
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_dirent_t_id_get",&obj0)) SWIG_fail;
8807
9554
  {
8808
 
    arg1 = (struct svn_fs_dirent_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_dirent_t, svn_argnum_obj0);
 
9555
    arg1 = (struct svn_fs_dirent_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_dirent_t, svn_argnum_obj0);
8809
9556
    if (PyErr_Occurred()) {
8810
9557
      SWIG_fail;
8811
9558
    }
8812
9559
  }
8813
9560
  result = (svn_fs_id_t *) ((arg1)->id);
8814
 
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_fs_id_t,
 
9561
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_fs_id_t,
8815
9562
    _global_py_pool, args);
8816
9563
  return resultobj;
8817
9564
fail:
8828
9575
  
8829
9576
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_dirent_t_kind_set",&obj0,&obj1)) SWIG_fail;
8830
9577
  {
8831
 
    arg1 = (struct svn_fs_dirent_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_dirent_t, svn_argnum_obj0);
 
9578
    arg1 = (struct svn_fs_dirent_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_dirent_t, svn_argnum_obj0);
8832
9579
    if (PyErr_Occurred()) {
8833
9580
      SWIG_fail;
8834
9581
    }
8855
9602
  
8856
9603
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_dirent_t_kind_get",&obj0)) SWIG_fail;
8857
9604
  {
8858
 
    arg1 = (struct svn_fs_dirent_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_dirent_t, svn_argnum_obj0);
 
9605
    arg1 = (struct svn_fs_dirent_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_dirent_t, svn_argnum_obj0);
8859
9606
    if (PyErr_Occurred()) {
8860
9607
      SWIG_fail;
8861
9608
    }
8895
9642
  arg1 = &temp1;
8896
9643
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_dir_entries",&obj0,&arg3,&obj2)) SWIG_fail;
8897
9644
  {
8898
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
9645
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
8899
9646
    if (PyErr_Occurred()) {
8900
9647
      SWIG_fail;
8901
9648
    }
8948
9695
}
8949
9696
 
8950
9697
 
 
9698
SWIGINTERN PyObject *_wrap_svn_fs_dir_optimal_order(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
9699
  PyObject *resultobj = 0;
 
9700
  apr_array_header_t **arg1 = (apr_array_header_t **) 0 ;
 
9701
  svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
9702
  apr_hash_t *arg3 = (apr_hash_t *) 0 ;
 
9703
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
9704
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
9705
  apr_pool_t *_global_pool = NULL ;
 
9706
  PyObject *_global_py_pool = NULL ;
 
9707
  apr_array_header_t *temp1 ;
 
9708
  PyObject * obj0 = 0 ;
 
9709
  PyObject * obj1 = 0 ;
 
9710
  PyObject * obj2 = 0 ;
 
9711
  PyObject * obj3 = 0 ;
 
9712
  svn_error_t *result = 0 ;
 
9713
  
 
9714
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
9715
      &_global_py_pool, &_global_pool))
 
9716
  SWIG_fail;
 
9717
  arg4 = _global_pool;
 
9718
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
9719
      &_global_py_pool, &_global_pool))
 
9720
  SWIG_fail;
 
9721
  arg5 = _global_pool;
 
9722
  arg1 = &temp1;
 
9723
  if (!PyArg_ParseTuple(args,(char *)"OO|OO:svn_fs_dir_optimal_order",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
9724
  {
 
9725
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
9726
    if (PyErr_Occurred()) {
 
9727
      SWIG_fail;
 
9728
    }
 
9729
  }
 
9730
  {
 
9731
    arg3 = (apr_hash_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_apr_hash_t, svn_argnum_obj1);
 
9732
    if (PyErr_Occurred()) {
 
9733
      SWIG_fail;
 
9734
    }
 
9735
  }
 
9736
  if (obj2) {
 
9737
    /* Verify that the user supplied a valid pool */
 
9738
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
9739
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
9740
      SWIG_arg_fail(svn_argnum_obj2);
 
9741
      SWIG_fail;
 
9742
    }
 
9743
  }
 
9744
  if (obj3) {
 
9745
    /* Verify that the user supplied a valid pool */
 
9746
    if (obj3 != Py_None && obj3 != _global_py_pool) {
 
9747
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
 
9748
      SWIG_arg_fail(svn_argnum_obj3);
 
9749
      SWIG_fail;
 
9750
    }
 
9751
  }
 
9752
  {
 
9753
    svn_swig_py_release_py_lock();
 
9754
    
 
9755
    result = (svn_error_t *)svn_fs_dir_optimal_order(arg1,arg2,arg3,arg4,arg5);
 
9756
    
 
9757
    svn_swig_py_acquire_py_lock();
 
9758
    
 
9759
  }
 
9760
  {
 
9761
    if (result != NULL) {
 
9762
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
9763
      svn_swig_py_svn_exception(result);
 
9764
      else
 
9765
      svn_error_clear(result);
 
9766
      SWIG_fail;
 
9767
    }
 
9768
    Py_INCREF(Py_None);
 
9769
    resultobj = Py_None;
 
9770
  }
 
9771
  {
 
9772
    /* FIXME: Missing argout typemap: svn_fs_dir_optimal_order arg 1 (apr_array_header_t **) */
 
9773
    
 
9774
    
 
9775
    
 
9776
    
 
9777
    SWIG_exception(SWIG_ValueError, "svn_fs_dir_optimal_order is not implemented yet");
 
9778
    
 
9779
  }
 
9780
  {
 
9781
    Py_XDECREF(_global_py_pool);
 
9782
  }
 
9783
  {
 
9784
    Py_XDECREF(_global_py_pool);
 
9785
  }
 
9786
  return resultobj;
 
9787
fail:
 
9788
  {
 
9789
    Py_XDECREF(_global_py_pool);
 
9790
  }
 
9791
  {
 
9792
    Py_XDECREF(_global_py_pool);
 
9793
  }
 
9794
  return NULL;
 
9795
}
 
9796
 
 
9797
 
8951
9798
SWIGINTERN PyObject *_wrap_svn_fs_make_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8952
9799
  PyObject *resultobj = 0;
8953
9800
  svn_fs_root_t *arg1 = (svn_fs_root_t *) 0 ;
8965
9812
  arg3 = _global_pool;
8966
9813
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_make_dir",&obj0,&arg2,&obj2)) SWIG_fail;
8967
9814
  {
8968
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
9815
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
8969
9816
    if (PyErr_Occurred()) {
8970
9817
      SWIG_fail;
8971
9818
    }
9026
9873
  arg3 = _global_pool;
9027
9874
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_delete",&obj0,&arg2,&obj2)) SWIG_fail;
9028
9875
  {
9029
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
9876
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
9030
9877
    if (PyErr_Occurred()) {
9031
9878
      SWIG_fail;
9032
9879
    }
9090
9937
  arg5 = _global_pool;
9091
9938
  if (!PyArg_ParseTuple(args,(char *)"OsOs|O:svn_fs_copy",&obj0,&arg2,&obj2,&arg4,&obj4)) SWIG_fail;
9092
9939
  {
9093
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
9940
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
9094
9941
    if (PyErr_Occurred()) {
9095
9942
      SWIG_fail;
9096
9943
    }
9097
9944
  }
9098
9945
  {
9099
 
    arg3 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
 
9946
    arg3 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
9100
9947
    if (PyErr_Occurred()) {
9101
9948
      SWIG_fail;
9102
9949
    }
9159
10006
  arg4 = _global_pool;
9160
10007
  if (!PyArg_ParseTuple(args,(char *)"OOs|O:svn_fs_revision_link",&obj0,&obj1,&arg3,&obj3)) SWIG_fail;
9161
10008
  {
9162
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
10009
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
9163
10010
    if (PyErr_Occurred()) {
9164
10011
      SWIG_fail;
9165
10012
    }
9166
10013
  }
9167
10014
  {
9168
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj1);
 
10015
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj1);
9169
10016
    if (PyErr_Occurred()) {
9170
10017
      SWIG_fail;
9171
10018
    }
9229
10076
  arg1 = &temp1;
9230
10077
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_file_length",&obj0,&arg3,&obj2)) SWIG_fail;
9231
10078
  {
9232
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
10079
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
9233
10080
    if (PyErr_Occurred()) {
9234
10081
      SWIG_fail;
9235
10082
    }
9306
10153
    }
9307
10154
  }
9308
10155
  {
9309
 
    arg3 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj1);
 
10156
    arg3 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj1);
9310
10157
    if (PyErr_Occurred()) {
9311
10158
      SWIG_fail;
9312
10159
    }
9385
10232
  arg1 = temp1;
9386
10233
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_file_md5_checksum",&obj0,&arg3,&obj2)) SWIG_fail;
9387
10234
  {
9388
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
10235
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
9389
10236
    if (PyErr_Occurred()) {
9390
10237
      SWIG_fail;
9391
10238
    }
9452
10299
  arg1 = &temp1;
9453
10300
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_file_contents",&obj0,&arg3,&obj2)) SWIG_fail;
9454
10301
  {
9455
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
10302
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
9456
10303
    if (PyErr_Occurred()) {
9457
10304
      SWIG_fail;
9458
10305
    }
9485
10332
    resultobj = Py_None;
9486
10333
  }
9487
10334
  {
9488
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_stream_t,
 
10335
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_stream_t,
9489
10336
        _global_py_pool, args))
9490
10337
    
9491
10338
    ;
9527
10374
  arg1 = &temp1;
9528
10375
  if (!PyArg_ParseTuple(args,(char *)"OsOO|O:svn_fs_try_process_file_contents",&obj0,&arg3,&obj2,&obj3,&obj4)) SWIG_fail;
9529
10376
  {
9530
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
10377
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
9531
10378
    if (PyErr_Occurred()) {
9532
10379
      SWIG_fail;
9533
10380
    }
9534
10381
  }
9535
10382
  {
9536
10383
    svn_fs_process_contents_func_t * tmp =
9537
 
    svn_swig_MustGetPtr(obj2, SWIGTYPE_p_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj2);
 
10384
    svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj2);
9538
10385
    if (tmp == NULL || PyErr_Occurred()) {
9539
10386
      SWIG_fail;
9540
10387
    }
9610
10457
  arg3 = _global_pool;
9611
10458
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_make_file",&obj0,&arg2,&obj2)) SWIG_fail;
9612
10459
  {
9613
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
10460
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
9614
10461
    if (PyErr_Occurred()) {
9615
10462
      SWIG_fail;
9616
10463
    }
9687
10534
  arg2 = &temp2;
9688
10535
  if (!PyArg_ParseTuple(args,(char *)"Oszz|O:svn_fs_apply_textdelta",&obj0,&arg4,&arg5,&arg6,&obj4)) SWIG_fail;
9689
10536
  {
9690
 
    arg3 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
10537
    arg3 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
9691
10538
    if (PyErr_Occurred()) {
9692
10539
      SWIG_fail;
9693
10540
    }
9720
10567
    resultobj = Py_None;
9721
10568
  }
9722
10569
  {
9723
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(arg1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
 
10570
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(arg1, SWIGTYPE_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
9724
10571
        _global_py_pool, args))
9725
10572
    
9726
10573
    ;
9727
10574
  }
9728
10575
  {
9729
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
 
10576
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg2, SWIGTYPE_p_void,
9730
10577
        _global_py_pool, args))
9731
10578
    
9732
10579
    ;
9764
10611
  arg1 = &temp1;
9765
10612
  if (!PyArg_ParseTuple(args,(char *)"Osz|O:svn_fs_apply_text",&obj0,&arg3,&arg4,&obj3)) SWIG_fail;
9766
10613
  {
9767
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
10614
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
9768
10615
    if (PyErr_Occurred()) {
9769
10616
      SWIG_fail;
9770
10617
    }
9797
10644
    resultobj = Py_None;
9798
10645
  }
9799
10646
  {
9800
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_stream_t,
 
10647
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_stream_t,
9801
10648
        _global_py_pool, args))
9802
10649
    
9803
10650
    ;
9814
10661
}
9815
10662
 
9816
10663
 
 
10664
SWIGINTERN PyObject *_wrap_svn_fs_contents_different(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10665
  PyObject *resultobj = 0;
 
10666
  svn_boolean_t *arg1 = (svn_boolean_t *) 0 ;
 
10667
  svn_fs_root_t *arg2 = (svn_fs_root_t *) 0 ;
 
10668
  char *arg3 = (char *) 0 ;
 
10669
  svn_fs_root_t *arg4 = (svn_fs_root_t *) 0 ;
 
10670
  char *arg5 = (char *) 0 ;
 
10671
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
10672
  apr_pool_t *_global_pool = NULL ;
 
10673
  PyObject *_global_py_pool = NULL ;
 
10674
  svn_boolean_t temp1 ;
 
10675
  int res1 = SWIG_TMPOBJ ;
 
10676
  PyObject * obj0 = 0 ;
 
10677
  PyObject * obj2 = 0 ;
 
10678
  PyObject * obj4 = 0 ;
 
10679
  svn_error_t *result = 0 ;
 
10680
  
 
10681
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
10682
      &_global_py_pool, &_global_pool))
 
10683
  SWIG_fail;
 
10684
  arg6 = _global_pool;
 
10685
  arg1 = &temp1;
 
10686
  if (!PyArg_ParseTuple(args,(char *)"OsOs|O:svn_fs_contents_different",&obj0,&arg3,&obj2,&arg5,&obj4)) SWIG_fail;
 
10687
  {
 
10688
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
10689
    if (PyErr_Occurred()) {
 
10690
      SWIG_fail;
 
10691
    }
 
10692
  }
 
10693
  {
 
10694
    arg4 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
 
10695
    if (PyErr_Occurred()) {
 
10696
      SWIG_fail;
 
10697
    }
 
10698
  }
 
10699
  if (obj4) {
 
10700
    /* Verify that the user supplied a valid pool */
 
10701
    if (obj4 != Py_None && obj4 != _global_py_pool) {
 
10702
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
 
10703
      SWIG_arg_fail(svn_argnum_obj4);
 
10704
      SWIG_fail;
 
10705
    }
 
10706
  }
 
10707
  {
 
10708
    svn_swig_py_release_py_lock();
 
10709
    
 
10710
    result = (svn_error_t *)svn_fs_contents_different(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,arg6);
 
10711
    
 
10712
    svn_swig_py_acquire_py_lock();
 
10713
    
 
10714
  }
 
10715
  {
 
10716
    if (result != NULL) {
 
10717
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
10718
      svn_swig_py_svn_exception(result);
 
10719
      else
 
10720
      svn_error_clear(result);
 
10721
      SWIG_fail;
 
10722
    }
 
10723
    Py_INCREF(Py_None);
 
10724
    resultobj = Py_None;
 
10725
  }
 
10726
  if (SWIG_IsTmpObj(res1)) {
 
10727
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
 
10728
  } else {
 
10729
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
10730
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
 
10731
  }
 
10732
  {
 
10733
    Py_XDECREF(_global_py_pool);
 
10734
  }
 
10735
  return resultobj;
 
10736
fail:
 
10737
  {
 
10738
    Py_XDECREF(_global_py_pool);
 
10739
  }
 
10740
  return NULL;
 
10741
}
 
10742
 
 
10743
 
9817
10744
SWIGINTERN PyObject *_wrap_svn_fs_contents_changed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9818
10745
  PyObject *resultobj = 0;
9819
10746
  svn_boolean_t *arg1 = (svn_boolean_t *) 0 ;
9838
10765
  arg1 = &temp1;
9839
10766
  if (!PyArg_ParseTuple(args,(char *)"OsOs|O:svn_fs_contents_changed",&obj0,&arg3,&obj2,&arg5,&obj4)) SWIG_fail;
9840
10767
  {
9841
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
10768
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
9842
10769
    if (PyErr_Occurred()) {
9843
10770
      SWIG_fail;
9844
10771
    }
9845
10772
  }
9846
10773
  {
9847
 
    arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
 
10774
    arg4 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
9848
10775
    if (PyErr_Occurred()) {
9849
10776
      SWIG_fail;
9850
10777
    }
9914
10841
  arg1 = &temp1;
9915
10842
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_youngest_rev",&obj0,&obj1)) SWIG_fail;
9916
10843
  {
9917
 
    arg2 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
10844
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
9918
10845
    if (PyErr_Occurred()) {
9919
10846
      SWIG_fail;
9920
10847
    }
9964
10891
}
9965
10892
 
9966
10893
 
 
10894
SWIGINTERN PyObject *_wrap_svn_fs_info_format(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10895
  PyObject *resultobj = 0;
 
10896
  int *arg1 = (int *) 0 ;
 
10897
  svn_version_t **arg2 = (svn_version_t **) 0 ;
 
10898
  svn_fs_t *arg3 = (svn_fs_t *) 0 ;
 
10899
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
10900
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
10901
  apr_pool_t *_global_pool = NULL ;
 
10902
  PyObject *_global_py_pool = NULL ;
 
10903
  int temp1 ;
 
10904
  int res1 = SWIG_TMPOBJ ;
 
10905
  svn_version_t *temp2 ;
 
10906
  PyObject * obj0 = 0 ;
 
10907
  PyObject * obj1 = 0 ;
 
10908
  PyObject * obj2 = 0 ;
 
10909
  svn_error_t *result = 0 ;
 
10910
  
 
10911
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
10912
      &_global_py_pool, &_global_pool))
 
10913
  SWIG_fail;
 
10914
  arg4 = _global_pool;
 
10915
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
10916
      &_global_py_pool, &_global_pool))
 
10917
  SWIG_fail;
 
10918
  arg5 = _global_pool;
 
10919
  arg1 = &temp1;
 
10920
  arg2 = &temp2;
 
10921
  if (!PyArg_ParseTuple(args,(char *)"O|OO:svn_fs_info_format",&obj0,&obj1,&obj2)) SWIG_fail;
 
10922
  {
 
10923
    arg3 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
10924
    if (PyErr_Occurred()) {
 
10925
      SWIG_fail;
 
10926
    }
 
10927
  }
 
10928
  if (obj1) {
 
10929
    /* Verify that the user supplied a valid pool */
 
10930
    if (obj1 != Py_None && obj1 != _global_py_pool) {
 
10931
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
 
10932
      SWIG_arg_fail(svn_argnum_obj1);
 
10933
      SWIG_fail;
 
10934
    }
 
10935
  }
 
10936
  if (obj2) {
 
10937
    /* Verify that the user supplied a valid pool */
 
10938
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
10939
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
10940
      SWIG_arg_fail(svn_argnum_obj2);
 
10941
      SWIG_fail;
 
10942
    }
 
10943
  }
 
10944
  {
 
10945
    svn_swig_py_release_py_lock();
 
10946
    
 
10947
    result = (svn_error_t *)svn_fs_info_format(arg1,arg2,arg3,arg4,arg5);
 
10948
    
 
10949
    svn_swig_py_acquire_py_lock();
 
10950
    
 
10951
  }
 
10952
  {
 
10953
    if (result != NULL) {
 
10954
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
10955
      svn_swig_py_svn_exception(result);
 
10956
      else
 
10957
      svn_error_clear(result);
 
10958
      SWIG_fail;
 
10959
    }
 
10960
    Py_INCREF(Py_None);
 
10961
    resultobj = Py_None;
 
10962
  }
 
10963
  if (SWIG_IsTmpObj(res1)) {
 
10964
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
 
10965
  } else {
 
10966
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
10967
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
 
10968
  }
 
10969
  {
 
10970
    /* FIXME: Missing argout typemap: svn_fs_info_format arg 2 (svn_version_t **) */
 
10971
    
 
10972
    
 
10973
    
 
10974
    
 
10975
    SWIG_exception(SWIG_ValueError, "svn_fs_info_format is not implemented yet");
 
10976
    
 
10977
  }
 
10978
  {
 
10979
    Py_XDECREF(_global_py_pool);
 
10980
  }
 
10981
  {
 
10982
    Py_XDECREF(_global_py_pool);
 
10983
  }
 
10984
  return resultobj;
 
10985
fail:
 
10986
  {
 
10987
    Py_XDECREF(_global_py_pool);
 
10988
  }
 
10989
  {
 
10990
    Py_XDECREF(_global_py_pool);
 
10991
  }
 
10992
  return NULL;
 
10993
}
 
10994
 
 
10995
 
 
10996
SWIGINTERN PyObject *_wrap_svn_fs_info_config_files(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10997
  PyObject *resultobj = 0;
 
10998
  apr_array_header_t **arg1 = (apr_array_header_t **) 0 ;
 
10999
  svn_fs_t *arg2 = (svn_fs_t *) 0 ;
 
11000
  apr_pool_t *arg3 = (apr_pool_t *) 0 ;
 
11001
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
11002
  apr_pool_t *_global_pool = NULL ;
 
11003
  PyObject *_global_py_pool = NULL ;
 
11004
  apr_array_header_t *temp1 ;
 
11005
  PyObject * obj0 = 0 ;
 
11006
  PyObject * obj1 = 0 ;
 
11007
  PyObject * obj2 = 0 ;
 
11008
  svn_error_t *result = 0 ;
 
11009
  
 
11010
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
11011
      &_global_py_pool, &_global_pool))
 
11012
  SWIG_fail;
 
11013
  arg3 = _global_pool;
 
11014
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
11015
      &_global_py_pool, &_global_pool))
 
11016
  SWIG_fail;
 
11017
  arg4 = _global_pool;
 
11018
  arg1 = &temp1;
 
11019
  if (!PyArg_ParseTuple(args,(char *)"O|OO:svn_fs_info_config_files",&obj0,&obj1,&obj2)) SWIG_fail;
 
11020
  {
 
11021
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
11022
    if (PyErr_Occurred()) {
 
11023
      SWIG_fail;
 
11024
    }
 
11025
  }
 
11026
  if (obj1) {
 
11027
    /* Verify that the user supplied a valid pool */
 
11028
    if (obj1 != Py_None && obj1 != _global_py_pool) {
 
11029
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
 
11030
      SWIG_arg_fail(svn_argnum_obj1);
 
11031
      SWIG_fail;
 
11032
    }
 
11033
  }
 
11034
  if (obj2) {
 
11035
    /* Verify that the user supplied a valid pool */
 
11036
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
11037
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
11038
      SWIG_arg_fail(svn_argnum_obj2);
 
11039
      SWIG_fail;
 
11040
    }
 
11041
  }
 
11042
  {
 
11043
    svn_swig_py_release_py_lock();
 
11044
    
 
11045
    result = (svn_error_t *)svn_fs_info_config_files(arg1,arg2,arg3,arg4);
 
11046
    
 
11047
    svn_swig_py_acquire_py_lock();
 
11048
    
 
11049
  }
 
11050
  {
 
11051
    if (result != NULL) {
 
11052
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
11053
      svn_swig_py_svn_exception(result);
 
11054
      else
 
11055
      svn_error_clear(result);
 
11056
      SWIG_fail;
 
11057
    }
 
11058
    Py_INCREF(Py_None);
 
11059
    resultobj = Py_None;
 
11060
  }
 
11061
  {
 
11062
    /* FIXME: Missing argout typemap: svn_fs_info_config_files arg 1 (apr_array_header_t **) */
 
11063
    
 
11064
    
 
11065
    
 
11066
    
 
11067
    SWIG_exception(SWIG_ValueError, "svn_fs_info_config_files is not implemented yet");
 
11068
    
 
11069
  }
 
11070
  {
 
11071
    Py_XDECREF(_global_py_pool);
 
11072
  }
 
11073
  {
 
11074
    Py_XDECREF(_global_py_pool);
 
11075
  }
 
11076
  return resultobj;
 
11077
fail:
 
11078
  {
 
11079
    Py_XDECREF(_global_py_pool);
 
11080
  }
 
11081
  {
 
11082
    Py_XDECREF(_global_py_pool);
 
11083
  }
 
11084
  return NULL;
 
11085
}
 
11086
 
 
11087
 
9967
11088
SWIGINTERN PyObject *_wrap_svn_fs_deltify_revision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9968
11089
  PyObject *resultobj = 0;
9969
11090
  svn_fs_t *arg1 = (svn_fs_t *) 0 ;
9982
11103
  arg3 = _global_pool;
9983
11104
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_fs_deltify_revision",&obj0,&obj1,&obj2)) SWIG_fail;
9984
11105
  {
9985
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
11106
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
9986
11107
    if (PyErr_Occurred()) {
9987
11108
      SWIG_fail;
9988
11109
    }
10054
11175
  arg1 = &temp1;
10055
11176
  if (!PyArg_ParseTuple(args,(char *)"OOs|O:svn_fs_revision_prop",&obj0,&obj1,&arg4,&obj3)) SWIG_fail;
10056
11177
  {
10057
 
    arg2 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
11178
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
10058
11179
    if (PyErr_Occurred()) {
10059
11180
      SWIG_fail;
10060
11181
    }
10138
11259
  arg1 = &temp1;
10139
11260
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_fs_revision_proplist",&obj0,&obj1,&obj2)) SWIG_fail;
10140
11261
  {
10141
 
    arg2 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
11262
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
10142
11263
    if (PyErr_Occurred()) {
10143
11264
      SWIG_fail;
10144
11265
    }
10215
11336
  arg6 = _global_pool;
10216
11337
  if (!PyArg_ParseTuple(args,(char *)"OOsOO|O:svn_fs_change_rev_prop2",&obj0,&obj1,&arg3,&obj3,&obj4,&obj5)) SWIG_fail;
10217
11338
  {
10218
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
11339
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
10219
11340
    if (PyErr_Occurred()) {
10220
11341
      SWIG_fail;
10221
11342
    }
10227
11348
    }
10228
11349
  }
10229
11350
  {
10230
 
    arg4 = (svn_string_t **)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_p_svn_string_t, svn_argnum_obj3);
 
11351
    arg4 = (svn_string_t **)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_p_svn_string_t, svn_argnum_obj3);
10231
11352
    if (PyErr_Occurred()) {
10232
11353
      SWIG_fail;
10233
11354
    }
10319
11440
  arg5 = _global_pool;
10320
11441
  if (!PyArg_ParseTuple(args,(char *)"OOsO|O:svn_fs_change_rev_prop",&obj0,&obj1,&arg3,&obj3,&obj4)) SWIG_fail;
10321
11442
  {
10322
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
11443
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
10323
11444
    if (PyErr_Occurred()) {
10324
11445
      SWIG_fail;
10325
11446
    }
10405
11526
  arg1 = &temp1;
10406
11527
  if (!PyArg_ParseTuple(args,(char *)"OsOs|O:svn_fs_get_file_delta_stream",&obj0,&arg3,&obj2,&arg5,&obj4)) SWIG_fail;
10407
11528
  {
10408
 
    arg2 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
11529
    arg2 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
10409
11530
    if (PyErr_Occurred()) {
10410
11531
      SWIG_fail;
10411
11532
    }
10412
11533
  }
10413
11534
  {
10414
 
    arg4 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
 
11535
    arg4 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj2);
10415
11536
    if (PyErr_Occurred()) {
10416
11537
      SWIG_fail;
10417
11538
    }
10444
11565
    resultobj = Py_None;
10445
11566
  }
10446
11567
  {
10447
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_txdelta_stream_t,
 
11568
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_txdelta_stream_t,
10448
11569
        _global_py_pool, args))
10449
11570
    
10450
11571
    ;
10480
11601
  arg2 = &temp2;
10481
11602
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_get_uuid",&obj0,&obj1)) SWIG_fail;
10482
11603
  {
10483
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
11604
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
10484
11605
    if (PyErr_Occurred()) {
10485
11606
      SWIG_fail;
10486
11607
    }
10554
11675
  arg3 = _global_pool;
10555
11676
  if (!PyArg_ParseTuple(args,(char *)"Oz|O:svn_fs_set_uuid",&obj0,&arg2,&obj2)) SWIG_fail;
10556
11677
  {
10557
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
11678
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
10558
11679
    if (PyErr_Occurred()) {
10559
11680
      SWIG_fail;
10560
11681
    }
10598
11719
}
10599
11720
 
10600
11721
 
 
11722
SWIGINTERN PyObject *_wrap_svn_fs_lock_target_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
11723
  PyObject *resultobj = 0;
 
11724
  char *arg1 = (char *) 0 ;
 
11725
  svn_revnum_t arg2 ;
 
11726
  apr_pool_t *arg3 = (apr_pool_t *) 0 ;
 
11727
  apr_pool_t *_global_pool = NULL ;
 
11728
  PyObject *_global_py_pool = NULL ;
 
11729
  PyObject * obj1 = 0 ;
 
11730
  PyObject * obj2 = 0 ;
 
11731
  svn_fs_lock_target_t *result = 0 ;
 
11732
  
 
11733
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
11734
      &_global_py_pool, &_global_pool))
 
11735
  SWIG_fail;
 
11736
  arg3 = _global_pool;
 
11737
  if (!PyArg_ParseTuple(args,(char *)"zO|O:svn_fs_lock_target_create",&arg1,&obj1,&obj2)) SWIG_fail;
 
11738
  {
 
11739
    arg2 = (svn_revnum_t)SWIG_As_long (obj1);
 
11740
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
11741
      SWIG_fail;
 
11742
    }
 
11743
  }
 
11744
  if (obj2) {
 
11745
    /* Verify that the user supplied a valid pool */
 
11746
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
11747
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
11748
      SWIG_arg_fail(svn_argnum_obj2);
 
11749
      SWIG_fail;
 
11750
    }
 
11751
  }
 
11752
  {
 
11753
    svn_swig_py_release_py_lock();
 
11754
    
 
11755
    result = (svn_fs_lock_target_t *)svn_fs_lock_target_create((char const *)arg1,arg2,arg3);
 
11756
    
 
11757
    svn_swig_py_acquire_py_lock();
 
11758
    
 
11759
  }
 
11760
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_svn_fs_lock_target_t,
 
11761
    _global_py_pool, args);
 
11762
  {
 
11763
    Py_XDECREF(_global_py_pool);
 
11764
  }
 
11765
  return resultobj;
 
11766
fail:
 
11767
  {
 
11768
    Py_XDECREF(_global_py_pool);
 
11769
  }
 
11770
  return NULL;
 
11771
}
 
11772
 
 
11773
 
 
11774
SWIGINTERN PyObject *_wrap_svn_fs_lock_target_set_token(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
11775
  PyObject *resultobj = 0;
 
11776
  svn_fs_lock_target_t *arg1 = (svn_fs_lock_target_t *) 0 ;
 
11777
  char *arg2 = (char *) 0 ;
 
11778
  PyObject * obj0 = 0 ;
 
11779
  
 
11780
  if (!PyArg_ParseTuple(args,(char *)"Oz:svn_fs_lock_target_set_token",&obj0,&arg2)) SWIG_fail;
 
11781
  {
 
11782
    arg1 = (svn_fs_lock_target_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_lock_target_t, svn_argnum_obj0);
 
11783
    if (PyErr_Occurred()) {
 
11784
      SWIG_fail;
 
11785
    }
 
11786
  }
 
11787
  {
 
11788
    svn_swig_py_release_py_lock();
 
11789
    
 
11790
    svn_fs_lock_target_set_token(arg1,(char const *)arg2);
 
11791
    
 
11792
    svn_swig_py_acquire_py_lock();
 
11793
    
 
11794
  }
 
11795
  resultobj = SWIG_Py_Void();
 
11796
  return resultobj;
 
11797
fail:
 
11798
  return NULL;
 
11799
}
 
11800
 
 
11801
 
 
11802
SWIGINTERN PyObject *_wrap_svn_fs_lock_many(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
11803
  PyObject *resultobj = 0;
 
11804
  svn_fs_t *arg1 = (svn_fs_t *) 0 ;
 
11805
  apr_hash_t *arg2 = (apr_hash_t *) 0 ;
 
11806
  char *arg3 = (char *) 0 ;
 
11807
  svn_boolean_t arg4 ;
 
11808
  apr_time_t arg5 ;
 
11809
  svn_boolean_t arg6 ;
 
11810
  svn_fs_lock_callback_t arg7 = (svn_fs_lock_callback_t) 0 ;
 
11811
  void *arg8 = (void *) 0 ;
 
11812
  apr_pool_t *arg9 = (apr_pool_t *) 0 ;
 
11813
  apr_pool_t *arg10 = (apr_pool_t *) 0 ;
 
11814
  apr_pool_t *_global_pool = NULL ;
 
11815
  PyObject *_global_py_pool = NULL ;
 
11816
  PyObject * obj0 = 0 ;
 
11817
  PyObject * obj1 = 0 ;
 
11818
  PyObject * obj3 = 0 ;
 
11819
  PyObject * obj4 = 0 ;
 
11820
  PyObject * obj5 = 0 ;
 
11821
  PyObject * obj6 = 0 ;
 
11822
  PyObject * obj7 = 0 ;
 
11823
  PyObject * obj8 = 0 ;
 
11824
  svn_error_t *result = 0 ;
 
11825
  
 
11826
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
11827
      &_global_py_pool, &_global_pool))
 
11828
  SWIG_fail;
 
11829
  arg9 = _global_pool;
 
11830
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
11831
      &_global_py_pool, &_global_pool))
 
11832
  SWIG_fail;
 
11833
  arg10 = _global_pool;
 
11834
  if (!PyArg_ParseTuple(args,(char *)"OOzOOOO|OO:svn_fs_lock_many",&obj0,&obj1,&arg3,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
11835
  {
 
11836
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
11837
    if (PyErr_Occurred()) {
 
11838
      SWIG_fail;
 
11839
    }
 
11840
  }
 
11841
  {
 
11842
    if (_global_pool == NULL)
 
11843
    {
 
11844
      if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
 
11845
          &_global_py_pool, &_global_pool))
 
11846
      SWIG_fail;
 
11847
    }
 
11848
    arg2 = svn_swig_py_struct_ptr_hash_from_dict(obj1,
 
11849
      SWIGTYPE_p_svn_fs_lock_target_t, _global_pool);
 
11850
    if (PyErr_Occurred()) {
 
11851
      SWIG_fail;
 
11852
    }
 
11853
  }
 
11854
  {
 
11855
    arg4 = (svn_boolean_t)SWIG_As_long (obj3);
 
11856
    if (SWIG_arg_fail(svn_argnum_obj3)) {
 
11857
      SWIG_fail;
 
11858
    }
 
11859
  }
 
11860
  arg5 = (apr_time_t) PyLong_AsLongLong(obj4); 
 
11861
  {
 
11862
    arg6 = (svn_boolean_t)SWIG_As_long (obj5);
 
11863
    if (SWIG_arg_fail(svn_argnum_obj5)) {
 
11864
      SWIG_fail;
 
11865
    }
 
11866
  }
 
11867
  {
 
11868
    arg7 = (svn_fs_lock_callback_t) svn_swig_py_fs_lock_callback;
 
11869
    arg8 = obj6;
 
11870
  }
 
11871
  if (obj7) {
 
11872
    /* Verify that the user supplied a valid pool */
 
11873
    if (obj7 != Py_None && obj7 != _global_py_pool) {
 
11874
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj7);
 
11875
      SWIG_arg_fail(svn_argnum_obj7);
 
11876
      SWIG_fail;
 
11877
    }
 
11878
  }
 
11879
  if (obj8) {
 
11880
    /* Verify that the user supplied a valid pool */
 
11881
    if (obj8 != Py_None && obj8 != _global_py_pool) {
 
11882
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj8);
 
11883
      SWIG_arg_fail(svn_argnum_obj8);
 
11884
      SWIG_fail;
 
11885
    }
 
11886
  }
 
11887
  {
 
11888
    svn_swig_py_release_py_lock();
 
11889
    
 
11890
    result = (svn_error_t *)svn_fs_lock_many(arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
 
11891
    
 
11892
    svn_swig_py_acquire_py_lock();
 
11893
    
 
11894
  }
 
11895
  {
 
11896
    if (result != NULL) {
 
11897
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
11898
      svn_swig_py_svn_exception(result);
 
11899
      else
 
11900
      svn_error_clear(result);
 
11901
      SWIG_fail;
 
11902
    }
 
11903
    Py_INCREF(Py_None);
 
11904
    resultobj = Py_None;
 
11905
  }
 
11906
  {
 
11907
    Py_XDECREF(_global_py_pool);
 
11908
  }
 
11909
  {
 
11910
    Py_XDECREF(_global_py_pool);
 
11911
  }
 
11912
  return resultobj;
 
11913
fail:
 
11914
  {
 
11915
    Py_XDECREF(_global_py_pool);
 
11916
  }
 
11917
  {
 
11918
    Py_XDECREF(_global_py_pool);
 
11919
  }
 
11920
  return NULL;
 
11921
}
 
11922
 
 
11923
 
10601
11924
SWIGINTERN PyObject *_wrap_svn_fs_lock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10602
11925
  PyObject *resultobj = 0;
10603
11926
  svn_lock_t **arg1 = (svn_lock_t **) 0 ;
10628
11951
  arg1 = &temp1;
10629
11952
  if (!PyArg_ParseTuple(args,(char *)"OszzOOOO|O:svn_fs_lock",&obj0,&arg3,&arg4,&arg5,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
10630
11953
  {
10631
 
    arg2 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
11954
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
10632
11955
    if (PyErr_Occurred()) {
10633
11956
      SWIG_fail;
10634
11957
    }
10680
12003
    resultobj = Py_None;
10681
12004
  }
10682
12005
  {
10683
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_lock_t,
 
12006
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_lock_t,
10684
12007
        _global_py_pool, args))
10685
12008
    
10686
12009
    ;
10716
12039
  arg1 = &temp1;
10717
12040
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_generate_lock_token",&obj0,&obj1)) SWIG_fail;
10718
12041
  {
10719
 
    arg2 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
12042
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
10720
12043
    if (PyErr_Occurred()) {
10721
12044
      SWIG_fail;
10722
12045
    }
10773
12096
}
10774
12097
 
10775
12098
 
 
12099
SWIGINTERN PyObject *_wrap_svn_fs_unlock_many(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12100
  PyObject *resultobj = 0;
 
12101
  svn_fs_t *arg1 = (svn_fs_t *) 0 ;
 
12102
  apr_hash_t *arg2 = (apr_hash_t *) 0 ;
 
12103
  svn_boolean_t arg3 ;
 
12104
  svn_fs_lock_callback_t arg4 = (svn_fs_lock_callback_t) 0 ;
 
12105
  void *arg5 = (void *) 0 ;
 
12106
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
12107
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
 
12108
  apr_pool_t *_global_pool = NULL ;
 
12109
  PyObject *_global_py_pool = NULL ;
 
12110
  PyObject * obj0 = 0 ;
 
12111
  PyObject * obj1 = 0 ;
 
12112
  PyObject * obj2 = 0 ;
 
12113
  PyObject * obj3 = 0 ;
 
12114
  PyObject * obj4 = 0 ;
 
12115
  PyObject * obj5 = 0 ;
 
12116
  svn_error_t *result = 0 ;
 
12117
  
 
12118
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
12119
      &_global_py_pool, &_global_pool))
 
12120
  SWIG_fail;
 
12121
  arg6 = _global_pool;
 
12122
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
12123
      &_global_py_pool, &_global_pool))
 
12124
  SWIG_fail;
 
12125
  arg7 = _global_pool;
 
12126
  if (!PyArg_ParseTuple(args,(char *)"OOOO|OO:svn_fs_unlock_many",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
12127
  {
 
12128
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
12129
    if (PyErr_Occurred()) {
 
12130
      SWIG_fail;
 
12131
    }
 
12132
  }
 
12133
  {
 
12134
    arg2 = svn_swig_py_stringhash_from_dict(obj1, _global_pool);
 
12135
  }
 
12136
  {
 
12137
    arg3 = (svn_boolean_t)SWIG_As_long (obj2);
 
12138
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
12139
      SWIG_fail;
 
12140
    }
 
12141
  }
 
12142
  {
 
12143
    arg4 = (svn_fs_lock_callback_t) svn_swig_py_fs_lock_callback;
 
12144
    arg5 = obj3;
 
12145
  }
 
12146
  if (obj4) {
 
12147
    /* Verify that the user supplied a valid pool */
 
12148
    if (obj4 != Py_None && obj4 != _global_py_pool) {
 
12149
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
 
12150
      SWIG_arg_fail(svn_argnum_obj4);
 
12151
      SWIG_fail;
 
12152
    }
 
12153
  }
 
12154
  if (obj5) {
 
12155
    /* Verify that the user supplied a valid pool */
 
12156
    if (obj5 != Py_None && obj5 != _global_py_pool) {
 
12157
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
 
12158
      SWIG_arg_fail(svn_argnum_obj5);
 
12159
      SWIG_fail;
 
12160
    }
 
12161
  }
 
12162
  {
 
12163
    svn_swig_py_release_py_lock();
 
12164
    
 
12165
    result = (svn_error_t *)svn_fs_unlock_many(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
 
12166
    
 
12167
    svn_swig_py_acquire_py_lock();
 
12168
    
 
12169
  }
 
12170
  {
 
12171
    if (result != NULL) {
 
12172
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
12173
      svn_swig_py_svn_exception(result);
 
12174
      else
 
12175
      svn_error_clear(result);
 
12176
      SWIG_fail;
 
12177
    }
 
12178
    Py_INCREF(Py_None);
 
12179
    resultobj = Py_None;
 
12180
  }
 
12181
  {
 
12182
    Py_XDECREF(_global_py_pool);
 
12183
  }
 
12184
  {
 
12185
    Py_XDECREF(_global_py_pool);
 
12186
  }
 
12187
  return resultobj;
 
12188
fail:
 
12189
  {
 
12190
    Py_XDECREF(_global_py_pool);
 
12191
  }
 
12192
  {
 
12193
    Py_XDECREF(_global_py_pool);
 
12194
  }
 
12195
  return NULL;
 
12196
}
 
12197
 
 
12198
 
10776
12199
SWIGINTERN PyObject *_wrap_svn_fs_unlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10777
12200
  PyObject *resultobj = 0;
10778
12201
  svn_fs_t *arg1 = (svn_fs_t *) 0 ;
10793
12216
  arg5 = _global_pool;
10794
12217
  if (!PyArg_ParseTuple(args,(char *)"OszO|O:svn_fs_unlock",&obj0,&arg2,&arg3,&obj3,&obj4)) SWIG_fail;
10795
12218
  {
10796
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
12219
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
10797
12220
    if (PyErr_Occurred()) {
10798
12221
      SWIG_fail;
10799
12222
    }
10863
12286
  arg1 = &temp1;
10864
12287
  if (!PyArg_ParseTuple(args,(char *)"Os|O:svn_fs_get_lock",&obj0,&arg3,&obj2)) SWIG_fail;
10865
12288
  {
10866
 
    arg2 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
12289
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
10867
12290
    if (PyErr_Occurred()) {
10868
12291
      SWIG_fail;
10869
12292
    }
10896
12319
    resultobj = Py_None;
10897
12320
  }
10898
12321
  {
10899
 
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_lock_t,
 
12322
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_py_new_pointer_obj(*arg1, SWIGTYPE_p_svn_lock_t,
10900
12323
        _global_py_pool, args))
10901
12324
    
10902
12325
    ;
10935
12358
  arg6 = _global_pool;
10936
12359
  if (!PyArg_ParseTuple(args,(char *)"OsOO|O:svn_fs_get_locks2",&obj0,&arg2,&obj2,&obj3,&obj4)) SWIG_fail;
10937
12360
  {
10938
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
12361
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
10939
12362
    if (PyErr_Occurred()) {
10940
12363
      SWIG_fail;
10941
12364
    }
10947
12370
    }
10948
12371
  }
10949
12372
  {
10950
 
    arg4 = svn_swig_py_fs_get_locks_func;
 
12373
    arg4 = (svn_fs_get_locks_callback_t) svn_swig_py_fs_get_locks_func;
10951
12374
    arg5 = obj3;
10952
12375
  }
10953
12376
  if (obj4) {
11009
12432
  arg5 = _global_pool;
11010
12433
  if (!PyArg_ParseTuple(args,(char *)"OsO|O:svn_fs_get_locks",&obj0,&arg2,&obj2,&obj3)) SWIG_fail;
11011
12434
  {
11012
 
    arg1 = (svn_fs_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
12435
    arg1 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
11013
12436
    if (PyErr_Occurred()) {
11014
12437
      SWIG_fail;
11015
12438
    }
11016
12439
  }
11017
12440
  {
11018
 
    arg3 = svn_swig_py_fs_get_locks_func;
 
12441
    arg3 = (svn_fs_get_locks_callback_t) svn_swig_py_fs_get_locks_func;
11019
12442
    arg4 = obj2;
11020
12443
  }
11021
12444
  if (obj3) {
11144
12567
  if (!PyArg_ParseTuple(args,(char *)"sOOO|O:svn_fs_pack",&arg1,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11145
12568
  {
11146
12569
    svn_fs_pack_notify_t * tmp =
11147
 
    svn_swig_MustGetPtr(obj1, SWIGTYPE_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj1);
 
12570
    svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj1);
11148
12571
    if (tmp == NULL || PyErr_Occurred()) {
11149
12572
      SWIG_fail;
11150
12573
    }
11159
12582
    }
11160
12583
  }
11161
12584
  {
11162
 
    arg4 = svn_swig_py_cancel_func;
11163
 
    arg5 = obj3; /* our function is the baton. */
 
12585
    arg4 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
12586
    arg5 = obj3;
11164
12587
  }
11165
12588
  if (obj4) {
11166
12589
    /* Verify that the user supplied a valid pool */
11246
12669
  }
11247
12670
  {
11248
12671
    svn_fs_progress_notify_func_t * tmp =
11249
 
    svn_swig_MustGetPtr(obj4, SWIGTYPE_p_p_f_long_p_void_p_apr_pool_t__void, svn_argnum_obj4);
 
12672
    svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_p_f_long_p_void_p_apr_pool_t__void, svn_argnum_obj4);
11250
12673
    if (tmp == NULL || PyErr_Occurred()) {
11251
12674
      SWIG_fail;
11252
12675
    }
11261
12684
    }
11262
12685
  }
11263
12686
  {
11264
 
    arg7 = svn_swig_py_cancel_func;
11265
 
    arg8 = obj6; /* our function is the baton. */
 
12687
    arg7 = (svn_cancel_func_t) svn_swig_py_cancel_func;
 
12688
    arg8 = obj6;
11266
12689
  }
11267
12690
  if (obj7) {
11268
12691
    /* Verify that the user supplied a valid pool */
11319
12742
  arg2 = _global_pool;
11320
12743
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_fs_verify_root",&obj0,&obj1)) SWIG_fail;
11321
12744
  {
11322
 
    arg1 = (svn_fs_root_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
 
12745
    arg1 = (svn_fs_root_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_root_t, svn_argnum_obj0);
11323
12746
    if (PyErr_Occurred()) {
11324
12747
      SWIG_fail;
11325
12748
    }
11363
12786
}
11364
12787
 
11365
12788
 
 
12789
SWIGINTERN PyObject *_wrap_svn_fs_fsfs_info_t_fs_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12790
  PyObject *resultobj = 0;
 
12791
  struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12792
  char *arg2 = (char *) 0 ;
 
12793
  PyObject * obj0 = 0 ;
 
12794
  
 
12795
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_fs_fsfs_info_t_fs_type_set",&obj0,&arg2)) SWIG_fail;
 
12796
  {
 
12797
    arg1 = (struct svn_fs_fsfs_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsfs_info_t, svn_argnum_obj0);
 
12798
    if (PyErr_Occurred()) {
 
12799
      SWIG_fail;
 
12800
    }
 
12801
  }
 
12802
  {
 
12803
    apr_size_t len = strlen(arg2) + 1;
 
12804
    char *copied;
 
12805
    if (arg1->fs_type) free((char *)arg1->fs_type);
 
12806
    copied = malloc(len);
 
12807
    memcpy(copied, arg2, len);
 
12808
    arg1->fs_type = copied;
 
12809
  }
 
12810
  resultobj = SWIG_Py_Void();
 
12811
  return resultobj;
 
12812
fail:
 
12813
  return NULL;
 
12814
}
 
12815
 
 
12816
 
 
12817
SWIGINTERN PyObject *_wrap_svn_fs_fsfs_info_t_fs_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12818
  PyObject *resultobj = 0;
 
12819
  struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12820
  PyObject * obj0 = 0 ;
 
12821
  char *result = 0 ;
 
12822
  
 
12823
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_fsfs_info_t_fs_type_get",&obj0)) SWIG_fail;
 
12824
  {
 
12825
    arg1 = (struct svn_fs_fsfs_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsfs_info_t, svn_argnum_obj0);
 
12826
    if (PyErr_Occurred()) {
 
12827
      SWIG_fail;
 
12828
    }
 
12829
  }
 
12830
  result = (char *) ((arg1)->fs_type);
 
12831
  resultobj = SWIG_FromCharPtr((const char *)result);
 
12832
  return resultobj;
 
12833
fail:
 
12834
  return NULL;
 
12835
}
 
12836
 
 
12837
 
 
12838
SWIGINTERN PyObject *_wrap_svn_fs_fsfs_info_t_shard_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12839
  PyObject *resultobj = 0;
 
12840
  struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12841
  int arg2 ;
 
12842
  PyObject * obj0 = 0 ;
 
12843
  PyObject * obj1 = 0 ;
 
12844
  
 
12845
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_fsfs_info_t_shard_size_set",&obj0,&obj1)) SWIG_fail;
 
12846
  {
 
12847
    arg1 = (struct svn_fs_fsfs_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsfs_info_t, svn_argnum_obj0);
 
12848
    if (PyErr_Occurred()) {
 
12849
      SWIG_fail;
 
12850
    }
 
12851
  }
 
12852
  {
 
12853
    arg2 = (int)SWIG_As_long (obj1);
 
12854
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
12855
      SWIG_fail;
 
12856
    }
 
12857
  }
 
12858
  if (arg1) (arg1)->shard_size = arg2;
 
12859
  resultobj = SWIG_Py_Void();
 
12860
  return resultobj;
 
12861
fail:
 
12862
  return NULL;
 
12863
}
 
12864
 
 
12865
 
 
12866
SWIGINTERN PyObject *_wrap_svn_fs_fsfs_info_t_shard_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12867
  PyObject *resultobj = 0;
 
12868
  struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12869
  PyObject * obj0 = 0 ;
 
12870
  int result;
 
12871
  
 
12872
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_fsfs_info_t_shard_size_get",&obj0)) SWIG_fail;
 
12873
  {
 
12874
    arg1 = (struct svn_fs_fsfs_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsfs_info_t, svn_argnum_obj0);
 
12875
    if (PyErr_Occurred()) {
 
12876
      SWIG_fail;
 
12877
    }
 
12878
  }
 
12879
  result = (int) ((arg1)->shard_size);
 
12880
  resultobj = SWIG_From_long((long)(result));
 
12881
  return resultobj;
 
12882
fail:
 
12883
  return NULL;
 
12884
}
 
12885
 
 
12886
 
 
12887
SWIGINTERN PyObject *_wrap_svn_fs_fsfs_info_t_min_unpacked_rev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12888
  PyObject *resultobj = 0;
 
12889
  struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12890
  svn_revnum_t arg2 ;
 
12891
  PyObject * obj0 = 0 ;
 
12892
  PyObject * obj1 = 0 ;
 
12893
  
 
12894
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_fsfs_info_t_min_unpacked_rev_set",&obj0,&obj1)) SWIG_fail;
 
12895
  {
 
12896
    arg1 = (struct svn_fs_fsfs_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsfs_info_t, svn_argnum_obj0);
 
12897
    if (PyErr_Occurred()) {
 
12898
      SWIG_fail;
 
12899
    }
 
12900
  }
 
12901
  {
 
12902
    arg2 = (svn_revnum_t)SWIG_As_long (obj1);
 
12903
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
12904
      SWIG_fail;
 
12905
    }
 
12906
  }
 
12907
  if (arg1) (arg1)->min_unpacked_rev = arg2;
 
12908
  resultobj = SWIG_Py_Void();
 
12909
  return resultobj;
 
12910
fail:
 
12911
  return NULL;
 
12912
}
 
12913
 
 
12914
 
 
12915
SWIGINTERN PyObject *_wrap_svn_fs_fsfs_info_t_min_unpacked_rev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12916
  PyObject *resultobj = 0;
 
12917
  struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12918
  PyObject * obj0 = 0 ;
 
12919
  svn_revnum_t result;
 
12920
  
 
12921
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_fsfs_info_t_min_unpacked_rev_get",&obj0)) SWIG_fail;
 
12922
  {
 
12923
    arg1 = (struct svn_fs_fsfs_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsfs_info_t, svn_argnum_obj0);
 
12924
    if (PyErr_Occurred()) {
 
12925
      SWIG_fail;
 
12926
    }
 
12927
  }
 
12928
  result = (svn_revnum_t) ((arg1)->min_unpacked_rev);
 
12929
  resultobj = SWIG_From_long((long)(result));
 
12930
  return resultobj;
 
12931
fail:
 
12932
  return NULL;
 
12933
}
 
12934
 
 
12935
 
 
12936
SWIGINTERN PyObject *_wrap_svn_fs_fsfs_info_t_log_addressing_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12937
  PyObject *resultobj = 0;
 
12938
  struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12939
  svn_boolean_t arg2 ;
 
12940
  PyObject * obj0 = 0 ;
 
12941
  PyObject * obj1 = 0 ;
 
12942
  
 
12943
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_fsfs_info_t_log_addressing_set",&obj0,&obj1)) SWIG_fail;
 
12944
  {
 
12945
    arg1 = (struct svn_fs_fsfs_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsfs_info_t, svn_argnum_obj0);
 
12946
    if (PyErr_Occurred()) {
 
12947
      SWIG_fail;
 
12948
    }
 
12949
  }
 
12950
  {
 
12951
    arg2 = (svn_boolean_t)SWIG_As_long (obj1);
 
12952
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
12953
      SWIG_fail;
 
12954
    }
 
12955
  }
 
12956
  if (arg1) (arg1)->log_addressing = arg2;
 
12957
  resultobj = SWIG_Py_Void();
 
12958
  return resultobj;
 
12959
fail:
 
12960
  return NULL;
 
12961
}
 
12962
 
 
12963
 
 
12964
SWIGINTERN PyObject *_wrap_svn_fs_fsfs_info_t_log_addressing_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12965
  PyObject *resultobj = 0;
 
12966
  struct svn_fs_fsfs_info_t *arg1 = (struct svn_fs_fsfs_info_t *) 0 ;
 
12967
  PyObject * obj0 = 0 ;
 
12968
  svn_boolean_t result;
 
12969
  
 
12970
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_fsfs_info_t_log_addressing_get",&obj0)) SWIG_fail;
 
12971
  {
 
12972
    arg1 = (struct svn_fs_fsfs_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsfs_info_t, svn_argnum_obj0);
 
12973
    if (PyErr_Occurred()) {
 
12974
      SWIG_fail;
 
12975
    }
 
12976
  }
 
12977
  result = (svn_boolean_t) ((arg1)->log_addressing);
 
12978
  resultobj = SWIG_From_long((long)(result));
 
12979
  return resultobj;
 
12980
fail:
 
12981
  return NULL;
 
12982
}
 
12983
 
 
12984
 
 
12985
SWIGINTERN PyObject *svn_fs_fsfs_info_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12986
  PyObject *obj;
 
12987
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
12988
  SWIG_TypeNewClientData(SWIGTYPE_p_svn_fs_fsfs_info_t, SWIG_NewClientData(obj));
 
12989
  return SWIG_Py_Void();
 
12990
}
 
12991
 
 
12992
SWIGINTERN PyObject *_wrap_svn_fs_fsx_info_t_fs_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12993
  PyObject *resultobj = 0;
 
12994
  struct svn_fs_fsx_info_t *arg1 = (struct svn_fs_fsx_info_t *) 0 ;
 
12995
  char *arg2 = (char *) 0 ;
 
12996
  PyObject * obj0 = 0 ;
 
12997
  
 
12998
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_fs_fsx_info_t_fs_type_set",&obj0,&arg2)) SWIG_fail;
 
12999
  {
 
13000
    arg1 = (struct svn_fs_fsx_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsx_info_t, svn_argnum_obj0);
 
13001
    if (PyErr_Occurred()) {
 
13002
      SWIG_fail;
 
13003
    }
 
13004
  }
 
13005
  {
 
13006
    apr_size_t len = strlen(arg2) + 1;
 
13007
    char *copied;
 
13008
    if (arg1->fs_type) free((char *)arg1->fs_type);
 
13009
    copied = malloc(len);
 
13010
    memcpy(copied, arg2, len);
 
13011
    arg1->fs_type = copied;
 
13012
  }
 
13013
  resultobj = SWIG_Py_Void();
 
13014
  return resultobj;
 
13015
fail:
 
13016
  return NULL;
 
13017
}
 
13018
 
 
13019
 
 
13020
SWIGINTERN PyObject *_wrap_svn_fs_fsx_info_t_fs_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13021
  PyObject *resultobj = 0;
 
13022
  struct svn_fs_fsx_info_t *arg1 = (struct svn_fs_fsx_info_t *) 0 ;
 
13023
  PyObject * obj0 = 0 ;
 
13024
  char *result = 0 ;
 
13025
  
 
13026
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_fsx_info_t_fs_type_get",&obj0)) SWIG_fail;
 
13027
  {
 
13028
    arg1 = (struct svn_fs_fsx_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsx_info_t, svn_argnum_obj0);
 
13029
    if (PyErr_Occurred()) {
 
13030
      SWIG_fail;
 
13031
    }
 
13032
  }
 
13033
  result = (char *) ((arg1)->fs_type);
 
13034
  resultobj = SWIG_FromCharPtr((const char *)result);
 
13035
  return resultobj;
 
13036
fail:
 
13037
  return NULL;
 
13038
}
 
13039
 
 
13040
 
 
13041
SWIGINTERN PyObject *_wrap_svn_fs_fsx_info_t_shard_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13042
  PyObject *resultobj = 0;
 
13043
  struct svn_fs_fsx_info_t *arg1 = (struct svn_fs_fsx_info_t *) 0 ;
 
13044
  int arg2 ;
 
13045
  PyObject * obj0 = 0 ;
 
13046
  PyObject * obj1 = 0 ;
 
13047
  
 
13048
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_fsx_info_t_shard_size_set",&obj0,&obj1)) SWIG_fail;
 
13049
  {
 
13050
    arg1 = (struct svn_fs_fsx_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsx_info_t, svn_argnum_obj0);
 
13051
    if (PyErr_Occurred()) {
 
13052
      SWIG_fail;
 
13053
    }
 
13054
  }
 
13055
  {
 
13056
    arg2 = (int)SWIG_As_long (obj1);
 
13057
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
13058
      SWIG_fail;
 
13059
    }
 
13060
  }
 
13061
  if (arg1) (arg1)->shard_size = arg2;
 
13062
  resultobj = SWIG_Py_Void();
 
13063
  return resultobj;
 
13064
fail:
 
13065
  return NULL;
 
13066
}
 
13067
 
 
13068
 
 
13069
SWIGINTERN PyObject *_wrap_svn_fs_fsx_info_t_shard_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13070
  PyObject *resultobj = 0;
 
13071
  struct svn_fs_fsx_info_t *arg1 = (struct svn_fs_fsx_info_t *) 0 ;
 
13072
  PyObject * obj0 = 0 ;
 
13073
  int result;
 
13074
  
 
13075
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_fsx_info_t_shard_size_get",&obj0)) SWIG_fail;
 
13076
  {
 
13077
    arg1 = (struct svn_fs_fsx_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsx_info_t, svn_argnum_obj0);
 
13078
    if (PyErr_Occurred()) {
 
13079
      SWIG_fail;
 
13080
    }
 
13081
  }
 
13082
  result = (int) ((arg1)->shard_size);
 
13083
  resultobj = SWIG_From_long((long)(result));
 
13084
  return resultobj;
 
13085
fail:
 
13086
  return NULL;
 
13087
}
 
13088
 
 
13089
 
 
13090
SWIGINTERN PyObject *_wrap_svn_fs_fsx_info_t_min_unpacked_rev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13091
  PyObject *resultobj = 0;
 
13092
  struct svn_fs_fsx_info_t *arg1 = (struct svn_fs_fsx_info_t *) 0 ;
 
13093
  svn_revnum_t arg2 ;
 
13094
  PyObject * obj0 = 0 ;
 
13095
  PyObject * obj1 = 0 ;
 
13096
  
 
13097
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_fs_fsx_info_t_min_unpacked_rev_set",&obj0,&obj1)) SWIG_fail;
 
13098
  {
 
13099
    arg1 = (struct svn_fs_fsx_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsx_info_t, svn_argnum_obj0);
 
13100
    if (PyErr_Occurred()) {
 
13101
      SWIG_fail;
 
13102
    }
 
13103
  }
 
13104
  {
 
13105
    arg2 = (svn_revnum_t)SWIG_As_long (obj1);
 
13106
    if (SWIG_arg_fail(svn_argnum_obj1)) {
 
13107
      SWIG_fail;
 
13108
    }
 
13109
  }
 
13110
  if (arg1) (arg1)->min_unpacked_rev = arg2;
 
13111
  resultobj = SWIG_Py_Void();
 
13112
  return resultobj;
 
13113
fail:
 
13114
  return NULL;
 
13115
}
 
13116
 
 
13117
 
 
13118
SWIGINTERN PyObject *_wrap_svn_fs_fsx_info_t_min_unpacked_rev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13119
  PyObject *resultobj = 0;
 
13120
  struct svn_fs_fsx_info_t *arg1 = (struct svn_fs_fsx_info_t *) 0 ;
 
13121
  PyObject * obj0 = 0 ;
 
13122
  svn_revnum_t result;
 
13123
  
 
13124
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_fsx_info_t_min_unpacked_rev_get",&obj0)) SWIG_fail;
 
13125
  {
 
13126
    arg1 = (struct svn_fs_fsx_info_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_fsx_info_t, svn_argnum_obj0);
 
13127
    if (PyErr_Occurred()) {
 
13128
      SWIG_fail;
 
13129
    }
 
13130
  }
 
13131
  result = (svn_revnum_t) ((arg1)->min_unpacked_rev);
 
13132
  resultobj = SWIG_From_long((long)(result));
 
13133
  return resultobj;
 
13134
fail:
 
13135
  return NULL;
 
13136
}
 
13137
 
 
13138
 
 
13139
SWIGINTERN PyObject *svn_fs_fsx_info_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13140
  PyObject *obj;
 
13141
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
13142
  SWIG_TypeNewClientData(SWIGTYPE_p_svn_fs_fsx_info_t, SWIG_NewClientData(obj));
 
13143
  return SWIG_Py_Void();
 
13144
}
 
13145
 
 
13146
SWIGINTERN PyObject *_wrap_svn_fs_info_placeholder_t_fs_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13147
  PyObject *resultobj = 0;
 
13148
  struct svn_fs_info_placeholder_t *arg1 = (struct svn_fs_info_placeholder_t *) 0 ;
 
13149
  char *arg2 = (char *) 0 ;
 
13150
  PyObject * obj0 = 0 ;
 
13151
  
 
13152
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_fs_info_placeholder_t_fs_type_set",&obj0,&arg2)) SWIG_fail;
 
13153
  {
 
13154
    arg1 = (struct svn_fs_info_placeholder_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_info_placeholder_t, svn_argnum_obj0);
 
13155
    if (PyErr_Occurred()) {
 
13156
      SWIG_fail;
 
13157
    }
 
13158
  }
 
13159
  {
 
13160
    apr_size_t len = strlen(arg2) + 1;
 
13161
    char *copied;
 
13162
    if (arg1->fs_type) free((char *)arg1->fs_type);
 
13163
    copied = malloc(len);
 
13164
    memcpy(copied, arg2, len);
 
13165
    arg1->fs_type = copied;
 
13166
  }
 
13167
  resultobj = SWIG_Py_Void();
 
13168
  return resultobj;
 
13169
fail:
 
13170
  return NULL;
 
13171
}
 
13172
 
 
13173
 
 
13174
SWIGINTERN PyObject *_wrap_svn_fs_info_placeholder_t_fs_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13175
  PyObject *resultobj = 0;
 
13176
  struct svn_fs_info_placeholder_t *arg1 = (struct svn_fs_info_placeholder_t *) 0 ;
 
13177
  PyObject * obj0 = 0 ;
 
13178
  char *result = 0 ;
 
13179
  
 
13180
  if (!PyArg_ParseTuple(args,(char *)"O:svn_fs_info_placeholder_t_fs_type_get",&obj0)) SWIG_fail;
 
13181
  {
 
13182
    arg1 = (struct svn_fs_info_placeholder_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_info_placeholder_t, svn_argnum_obj0);
 
13183
    if (PyErr_Occurred()) {
 
13184
      SWIG_fail;
 
13185
    }
 
13186
  }
 
13187
  result = (char *) ((arg1)->fs_type);
 
13188
  resultobj = SWIG_FromCharPtr((const char *)result);
 
13189
  return resultobj;
 
13190
fail:
 
13191
  return NULL;
 
13192
}
 
13193
 
 
13194
 
 
13195
SWIGINTERN PyObject *svn_fs_info_placeholder_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13196
  PyObject *obj;
 
13197
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
13198
  SWIG_TypeNewClientData(SWIGTYPE_p_svn_fs_info_placeholder_t, SWIG_NewClientData(obj));
 
13199
  return SWIG_Py_Void();
 
13200
}
 
13201
 
 
13202
SWIGINTERN PyObject *_wrap_svn_fs_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13203
  PyObject *resultobj = 0;
 
13204
  svn_fs_info_placeholder_t **arg1 = (svn_fs_info_placeholder_t **) 0 ;
 
13205
  svn_fs_t *arg2 = (svn_fs_t *) 0 ;
 
13206
  apr_pool_t *arg3 = (apr_pool_t *) 0 ;
 
13207
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
 
13208
  apr_pool_t *_global_pool = NULL ;
 
13209
  PyObject *_global_py_pool = NULL ;
 
13210
  svn_fs_info_placeholder_t *temp1 ;
 
13211
  PyObject * obj0 = 0 ;
 
13212
  PyObject * obj1 = 0 ;
 
13213
  PyObject * obj2 = 0 ;
 
13214
  svn_error_t *result = 0 ;
 
13215
  
 
13216
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
13217
      &_global_py_pool, &_global_pool))
 
13218
  SWIG_fail;
 
13219
  arg3 = _global_pool;
 
13220
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
13221
      &_global_py_pool, &_global_pool))
 
13222
  SWIG_fail;
 
13223
  arg4 = _global_pool;
 
13224
  arg1 = &temp1;
 
13225
  if (!PyArg_ParseTuple(args,(char *)"O|OO:svn_fs_info",&obj0,&obj1,&obj2)) SWIG_fail;
 
13226
  {
 
13227
    arg2 = (svn_fs_t *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_svn_fs_t, svn_argnum_obj0);
 
13228
    if (PyErr_Occurred()) {
 
13229
      SWIG_fail;
 
13230
    }
 
13231
  }
 
13232
  if (obj1) {
 
13233
    /* Verify that the user supplied a valid pool */
 
13234
    if (obj1 != Py_None && obj1 != _global_py_pool) {
 
13235
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
 
13236
      SWIG_arg_fail(svn_argnum_obj1);
 
13237
      SWIG_fail;
 
13238
    }
 
13239
  }
 
13240
  if (obj2) {
 
13241
    /* Verify that the user supplied a valid pool */
 
13242
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
13243
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
13244
      SWIG_arg_fail(svn_argnum_obj2);
 
13245
      SWIG_fail;
 
13246
    }
 
13247
  }
 
13248
  {
 
13249
    svn_swig_py_release_py_lock();
 
13250
    
 
13251
    result = (svn_error_t *)svn_fs_info((struct svn_fs_info_placeholder_t const **)arg1,arg2,arg3,arg4);
 
13252
    
 
13253
    svn_swig_py_acquire_py_lock();
 
13254
    
 
13255
  }
 
13256
  {
 
13257
    if (result != NULL) {
 
13258
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
13259
      svn_swig_py_svn_exception(result);
 
13260
      else
 
13261
      svn_error_clear(result);
 
13262
      SWIG_fail;
 
13263
    }
 
13264
    Py_INCREF(Py_None);
 
13265
    resultobj = Py_None;
 
13266
  }
 
13267
  {
 
13268
    /* FIXME: Missing argout typemap: svn_fs_info arg 1 (svn_fs_info_placeholder_t const **) */
 
13269
    
 
13270
    
 
13271
    
 
13272
    
 
13273
    SWIG_exception(SWIG_ValueError, "svn_fs_info is not implemented yet");
 
13274
    
 
13275
  }
 
13276
  {
 
13277
    Py_XDECREF(_global_py_pool);
 
13278
  }
 
13279
  {
 
13280
    Py_XDECREF(_global_py_pool);
 
13281
  }
 
13282
  return resultobj;
 
13283
fail:
 
13284
  {
 
13285
    Py_XDECREF(_global_py_pool);
 
13286
  }
 
13287
  {
 
13288
    Py_XDECREF(_global_py_pool);
 
13289
  }
 
13290
  return NULL;
 
13291
}
 
13292
 
 
13293
 
 
13294
SWIGINTERN PyObject *_wrap_svn_fs_info_dup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13295
  PyObject *resultobj = 0;
 
13296
  void *arg1 = (void *) 0 ;
 
13297
  apr_pool_t *arg2 = (apr_pool_t *) 0 ;
 
13298
  apr_pool_t *arg3 = (apr_pool_t *) 0 ;
 
13299
  apr_pool_t *_global_pool = NULL ;
 
13300
  PyObject *_global_py_pool = NULL ;
 
13301
  PyObject * obj0 = 0 ;
 
13302
  PyObject * obj1 = 0 ;
 
13303
  PyObject * obj2 = 0 ;
 
13304
  void *result = 0 ;
 
13305
  
 
13306
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
13307
      &_global_py_pool, &_global_pool))
 
13308
  SWIG_fail;
 
13309
  arg2 = _global_pool;
 
13310
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
13311
      &_global_py_pool, &_global_pool))
 
13312
  SWIG_fail;
 
13313
  arg3 = _global_pool;
 
13314
  if (!PyArg_ParseTuple(args,(char *)"O|OO:svn_fs_info_dup",&obj0,&obj1,&obj2)) SWIG_fail;
 
13315
  {
 
13316
    arg1 = (void *)svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_void, svn_argnum_obj0);
 
13317
    if (PyErr_Occurred()) {
 
13318
      SWIG_fail;
 
13319
    }
 
13320
  }
 
13321
  if (obj1) {
 
13322
    /* Verify that the user supplied a valid pool */
 
13323
    if (obj1 != Py_None && obj1 != _global_py_pool) {
 
13324
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
 
13325
      SWIG_arg_fail(svn_argnum_obj1);
 
13326
      SWIG_fail;
 
13327
    }
 
13328
  }
 
13329
  if (obj2) {
 
13330
    /* Verify that the user supplied a valid pool */
 
13331
    if (obj2 != Py_None && obj2 != _global_py_pool) {
 
13332
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
 
13333
      SWIG_arg_fail(svn_argnum_obj2);
 
13334
      SWIG_fail;
 
13335
    }
 
13336
  }
 
13337
  {
 
13338
    svn_swig_py_release_py_lock();
 
13339
    
 
13340
    result = (void *)svn_fs_info_dup((void const *)arg1,arg2,arg3);
 
13341
    
 
13342
    svn_swig_py_acquire_py_lock();
 
13343
    
 
13344
  }
 
13345
  resultobj = svn_swig_py_new_pointer_obj((void*)(result), SWIGTYPE_p_void,
 
13346
    _global_py_pool, args);
 
13347
  {
 
13348
    Py_XDECREF(_global_py_pool);
 
13349
  }
 
13350
  {
 
13351
    Py_XDECREF(_global_py_pool);
 
13352
  }
 
13353
  return resultobj;
 
13354
fail:
 
13355
  {
 
13356
    Py_XDECREF(_global_py_pool);
 
13357
  }
 
13358
  {
 
13359
    Py_XDECREF(_global_py_pool);
 
13360
  }
 
13361
  return NULL;
 
13362
}
 
13363
 
 
13364
 
11366
13365
SWIGINTERN PyObject *svn_fs_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11367
13366
  PyObject *obj;
11368
13367
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
11405
13404
  return SWIG_Py_Void();
11406
13405
}
11407
13406
 
 
13407
SWIGINTERN PyObject *svn_fs_lock_target_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13408
  PyObject *obj;
 
13409
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
13410
  SWIG_TypeNewClientData(SWIGTYPE_p_svn_fs_lock_target_t, SWIG_NewClientData(obj));
 
13411
  return SWIG_Py_Void();
 
13412
}
 
13413
 
11408
13414
SWIGINTERN PyObject *_wrap_svn_fs_invoke_warning_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11409
13415
  PyObject *resultobj = 0;
11410
13416
  svn_fs_warning_callback_t arg1 = (svn_fs_warning_callback_t) 0 ;
11417
13423
  if (!PyArg_ParseTuple(args,(char *)"OOO:svn_fs_invoke_warning_callback",&obj0,&obj1,&obj2)) SWIG_fail;
11418
13424
  {
11419
13425
    svn_fs_warning_callback_t * tmp =
11420
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_p_struct_svn_error_t__void, svn_argnum_obj0);
 
13426
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_p_struct_svn_error_t__void, svn_argnum_obj0);
11421
13427
    if (tmp == NULL || PyErr_Occurred()) {
11422
13428
      SWIG_fail;
11423
13429
    }
11432
13438
    }
11433
13439
  }
11434
13440
  {
11435
 
    arg3 = (svn_error_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_error_t, svn_argnum_obj2);
 
13441
    arg3 = (svn_error_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_error_t, svn_argnum_obj2);
11436
13442
    if (PyErr_Occurred()) {
11437
13443
      SWIG_fail;
11438
13444
    }
11452
13458
}
11453
13459
 
11454
13460
 
 
13461
SWIGINTERN PyObject *_wrap_svn_fs_invoke_upgrade_notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13462
  PyObject *resultobj = 0;
 
13463
  svn_fs_upgrade_notify_t arg1 = (svn_fs_upgrade_notify_t) 0 ;
 
13464
  void *arg2 = (void *) 0 ;
 
13465
  apr_uint64_t arg3 ;
 
13466
  svn_fs_upgrade_notify_action_t arg4 ;
 
13467
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
13468
  apr_pool_t *_global_pool = NULL ;
 
13469
  PyObject *_global_py_pool = NULL ;
 
13470
  PyObject * obj0 = 0 ;
 
13471
  PyObject * obj1 = 0 ;
 
13472
  PyObject * obj2 = 0 ;
 
13473
  PyObject * obj3 = 0 ;
 
13474
  PyObject * obj4 = 0 ;
 
13475
  svn_error_t *result = 0 ;
 
13476
  
 
13477
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
13478
      &_global_py_pool, &_global_pool))
 
13479
  SWIG_fail;
 
13480
  arg5 = _global_pool;
 
13481
  if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_fs_invoke_upgrade_notify",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
13482
  {
 
13483
    svn_fs_upgrade_notify_t * tmp =
 
13484
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
13485
    if (tmp == NULL || PyErr_Occurred()) {
 
13486
      SWIG_fail;
 
13487
    }
 
13488
    arg1 = *tmp;
 
13489
  }
 
13490
  {
 
13491
    if (obj1 == Py_None) {
 
13492
      arg2 = NULL;
 
13493
    } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
 
13494
      arg2 = (void *) obj1;
 
13495
      PyErr_Clear();
 
13496
    }
 
13497
  }
 
13498
  arg3 = (apr_uint64_t) PyLong_AsUnsignedLongLong(obj2); 
 
13499
  {
 
13500
    arg4 = (svn_fs_upgrade_notify_action_t)SWIG_As_long (obj3);
 
13501
    if (SWIG_arg_fail(svn_argnum_obj3)) {
 
13502
      SWIG_fail;
 
13503
    }
 
13504
  }
 
13505
  if (obj4) {
 
13506
    /* Verify that the user supplied a valid pool */
 
13507
    if (obj4 != Py_None && obj4 != _global_py_pool) {
 
13508
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
 
13509
      SWIG_arg_fail(svn_argnum_obj4);
 
13510
      SWIG_fail;
 
13511
    }
 
13512
  }
 
13513
  {
 
13514
    svn_swig_py_release_py_lock();
 
13515
    
 
13516
    result = (svn_error_t *)svn_fs_invoke_upgrade_notify(arg1,arg2,arg3,arg4,arg5);
 
13517
    
 
13518
    svn_swig_py_acquire_py_lock();
 
13519
    
 
13520
  }
 
13521
  {
 
13522
    if (result != NULL) {
 
13523
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
13524
      svn_swig_py_svn_exception(result);
 
13525
      else
 
13526
      svn_error_clear(result);
 
13527
      SWIG_fail;
 
13528
    }
 
13529
    Py_INCREF(Py_None);
 
13530
    resultobj = Py_None;
 
13531
  }
 
13532
  {
 
13533
    Py_XDECREF(_global_py_pool);
 
13534
  }
 
13535
  return resultobj;
 
13536
fail:
 
13537
  {
 
13538
    Py_XDECREF(_global_py_pool);
 
13539
  }
 
13540
  return NULL;
 
13541
}
 
13542
 
 
13543
 
11455
13544
SWIGINTERN PyObject *_wrap_svn_fs_invoke_progress_notify_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11456
13545
  PyObject *resultobj = 0;
11457
13546
  svn_fs_progress_notify_func_t arg1 = (svn_fs_progress_notify_func_t) 0 ;
11472
13561
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_fs_invoke_progress_notify_func",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11473
13562
  {
11474
13563
    svn_fs_progress_notify_func_t * tmp =
11475
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_long_p_void_p_apr_pool_t__void, svn_argnum_obj0);
 
13564
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_long_p_void_p_apr_pool_t__void, svn_argnum_obj0);
11476
13565
    if (tmp == NULL || PyErr_Occurred()) {
11477
13566
      SWIG_fail;
11478
13567
    }
11521
13610
}
11522
13611
 
11523
13612
 
 
13613
SWIGINTERN PyObject *_wrap_svn_fs_invoke_hotcopy_notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13614
  PyObject *resultobj = 0;
 
13615
  svn_fs_hotcopy_notify_t arg1 = (svn_fs_hotcopy_notify_t) 0 ;
 
13616
  void *arg2 = (void *) 0 ;
 
13617
  svn_revnum_t arg3 ;
 
13618
  svn_revnum_t arg4 ;
 
13619
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
 
13620
  apr_pool_t *_global_pool = NULL ;
 
13621
  PyObject *_global_py_pool = NULL ;
 
13622
  PyObject * obj0 = 0 ;
 
13623
  PyObject * obj1 = 0 ;
 
13624
  PyObject * obj2 = 0 ;
 
13625
  PyObject * obj3 = 0 ;
 
13626
  PyObject * obj4 = 0 ;
 
13627
  
 
13628
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
13629
      &_global_py_pool, &_global_pool))
 
13630
  SWIG_fail;
 
13631
  arg5 = _global_pool;
 
13632
  if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_fs_invoke_hotcopy_notify",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
13633
  {
 
13634
    svn_fs_hotcopy_notify_t * tmp =
 
13635
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_long_long_p_apr_pool_t__void, svn_argnum_obj0);
 
13636
    if (tmp == NULL || PyErr_Occurred()) {
 
13637
      SWIG_fail;
 
13638
    }
 
13639
    arg1 = *tmp;
 
13640
  }
 
13641
  {
 
13642
    if (obj1 == Py_None) {
 
13643
      arg2 = NULL;
 
13644
    } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
 
13645
      arg2 = (void *) obj1;
 
13646
      PyErr_Clear();
 
13647
    }
 
13648
  }
 
13649
  {
 
13650
    arg3 = (svn_revnum_t)SWIG_As_long (obj2);
 
13651
    if (SWIG_arg_fail(svn_argnum_obj2)) {
 
13652
      SWIG_fail;
 
13653
    }
 
13654
  }
 
13655
  {
 
13656
    arg4 = (svn_revnum_t)SWIG_As_long (obj3);
 
13657
    if (SWIG_arg_fail(svn_argnum_obj3)) {
 
13658
      SWIG_fail;
 
13659
    }
 
13660
  }
 
13661
  if (obj4) {
 
13662
    /* Verify that the user supplied a valid pool */
 
13663
    if (obj4 != Py_None && obj4 != _global_py_pool) {
 
13664
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
 
13665
      SWIG_arg_fail(svn_argnum_obj4);
 
13666
      SWIG_fail;
 
13667
    }
 
13668
  }
 
13669
  {
 
13670
    svn_swig_py_release_py_lock();
 
13671
    
 
13672
    svn_fs_invoke_hotcopy_notify(arg1,arg2,arg3,arg4,arg5);
 
13673
    
 
13674
    svn_swig_py_acquire_py_lock();
 
13675
    
 
13676
  }
 
13677
  resultobj = SWIG_Py_Void();
 
13678
  {
 
13679
    Py_XDECREF(_global_py_pool);
 
13680
  }
 
13681
  return resultobj;
 
13682
fail:
 
13683
  {
 
13684
    Py_XDECREF(_global_py_pool);
 
13685
  }
 
13686
  return NULL;
 
13687
}
 
13688
 
 
13689
 
11524
13690
SWIGINTERN PyObject *_wrap_svn_fs_invoke_freeze_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11525
13691
  PyObject *resultobj = 0;
11526
13692
  svn_fs_freeze_func_t arg1 = (svn_fs_freeze_func_t) 0 ;
11540
13706
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_fs_invoke_freeze_func",&obj0,&obj1,&obj2)) SWIG_fail;
11541
13707
  {
11542
13708
    svn_fs_freeze_func_t * tmp =
11543
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
13709
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
11544
13710
    if (tmp == NULL || PyErr_Occurred()) {
11545
13711
      SWIG_fail;
11546
13712
    }
11616
13782
  if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_fs_invoke_process_contents_func",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11617
13783
  {
11618
13784
    svn_fs_process_contents_func_t * tmp =
11619
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
13785
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
11620
13786
    if (tmp == NULL || PyErr_Occurred()) {
11621
13787
      SWIG_fail;
11622
13788
    }
11623
13789
    arg1 = *tmp;
11624
13790
  }
11625
13791
  {
11626
 
    arg2 = (unsigned char *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_unsigned_char, svn_argnum_obj1);
 
13792
    arg2 = (unsigned char *)svn_swig_py_must_get_ptr(obj1, SWIGTYPE_p_unsigned_char, svn_argnum_obj1);
11627
13793
    if (PyErr_Occurred()) {
11628
13794
      SWIG_fail;
11629
13795
    }
11681
13847
}
11682
13848
 
11683
13849
 
 
13850
SWIGINTERN PyObject *_wrap_svn_fs_invoke_lock_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13851
  PyObject *resultobj = 0;
 
13852
  svn_fs_lock_callback_t arg1 = (svn_fs_lock_callback_t) 0 ;
 
13853
  void *arg2 = (void *) 0 ;
 
13854
  char *arg3 = (char *) 0 ;
 
13855
  svn_lock_t *arg4 = (svn_lock_t *) 0 ;
 
13856
  svn_error_t *arg5 = (svn_error_t *) 0 ;
 
13857
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
 
13858
  apr_pool_t *_global_pool = NULL ;
 
13859
  PyObject *_global_py_pool = NULL ;
 
13860
  PyObject * obj0 = 0 ;
 
13861
  PyObject * obj1 = 0 ;
 
13862
  PyObject * obj3 = 0 ;
 
13863
  PyObject * obj4 = 0 ;
 
13864
  PyObject * obj5 = 0 ;
 
13865
  svn_error_t *result = 0 ;
 
13866
  
 
13867
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
 
13868
      &_global_py_pool, &_global_pool))
 
13869
  SWIG_fail;
 
13870
  arg6 = _global_pool;
 
13871
  if (!PyArg_ParseTuple(args,(char *)"OOsOO|O:svn_fs_invoke_lock_callback",&obj0,&obj1,&arg3,&obj3,&obj4,&obj5)) SWIG_fail;
 
13872
  {
 
13873
    svn_fs_lock_callback_t * tmp =
 
13874
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
13875
    if (tmp == NULL || PyErr_Occurred()) {
 
13876
      SWIG_fail;
 
13877
    }
 
13878
    arg1 = *tmp;
 
13879
  }
 
13880
  {
 
13881
    if (obj1 == Py_None) {
 
13882
      arg2 = NULL;
 
13883
    } else if (SWIG_ConvertPtr(obj1, (void **) &arg2, 0, 0) == -1) {
 
13884
      arg2 = (void *) obj1;
 
13885
      PyErr_Clear();
 
13886
    }
 
13887
  }
 
13888
  {
 
13889
    arg4 = (svn_lock_t *)svn_swig_py_must_get_ptr(obj3, SWIGTYPE_p_svn_lock_t, svn_argnum_obj3);
 
13890
    if (PyErr_Occurred()) {
 
13891
      SWIG_fail;
 
13892
    }
 
13893
  }
 
13894
  {
 
13895
    arg5 = (svn_error_t *)svn_swig_py_must_get_ptr(obj4, SWIGTYPE_p_svn_error_t, svn_argnum_obj4);
 
13896
    if (PyErr_Occurred()) {
 
13897
      SWIG_fail;
 
13898
    }
 
13899
  }
 
13900
  if (obj5) {
 
13901
    /* Verify that the user supplied a valid pool */
 
13902
    if (obj5 != Py_None && obj5 != _global_py_pool) {
 
13903
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
 
13904
      SWIG_arg_fail(svn_argnum_obj5);
 
13905
      SWIG_fail;
 
13906
    }
 
13907
  }
 
13908
  {
 
13909
    svn_swig_py_release_py_lock();
 
13910
    
 
13911
    result = (svn_error_t *)svn_fs_invoke_lock_callback(arg1,arg2,(char const *)arg3,(struct svn_lock_t const *)arg4,arg5,arg6);
 
13912
    
 
13913
    svn_swig_py_acquire_py_lock();
 
13914
    
 
13915
  }
 
13916
  {
 
13917
    if (result != NULL) {
 
13918
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
 
13919
      svn_swig_py_svn_exception(result);
 
13920
      else
 
13921
      svn_error_clear(result);
 
13922
      SWIG_fail;
 
13923
    }
 
13924
    Py_INCREF(Py_None);
 
13925
    resultobj = Py_None;
 
13926
  }
 
13927
  {
 
13928
    Py_XDECREF(_global_py_pool);
 
13929
  }
 
13930
  return resultobj;
 
13931
fail:
 
13932
  {
 
13933
    Py_XDECREF(_global_py_pool);
 
13934
  }
 
13935
  return NULL;
 
13936
}
 
13937
 
 
13938
 
11684
13939
SWIGINTERN PyObject *_wrap_svn_fs_invoke_get_locks_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11685
13940
  PyObject *resultobj = 0;
11686
13941
  svn_fs_get_locks_callback_t arg1 = (svn_fs_get_locks_callback_t) 0 ;
11702
13957
  if (!PyArg_ParseTuple(args,(char *)"OOO|O:svn_fs_invoke_get_locks_callback",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11703
13958
  {
11704
13959
    svn_fs_get_locks_callback_t * tmp =
11705
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
13960
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
11706
13961
    if (tmp == NULL || PyErr_Occurred()) {
11707
13962
      SWIG_fail;
11708
13963
    }
11717
13972
    }
11718
13973
  }
11719
13974
  {
11720
 
    arg3 = (svn_lock_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_lock_t, svn_argnum_obj2);
 
13975
    arg3 = (svn_lock_t *)svn_swig_py_must_get_ptr(obj2, SWIGTYPE_p_svn_lock_t, svn_argnum_obj2);
11721
13976
    if (PyErr_Occurred()) {
11722
13977
      SWIG_fail;
11723
13978
    }
11784
14039
  if (!PyArg_ParseTuple(args,(char *)"OOOO|O:svn_fs_invoke_pack_notify",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11785
14040
  {
11786
14041
    svn_fs_pack_notify_t * tmp =
11787
 
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
 
14042
    svn_swig_py_must_get_ptr(obj0, SWIGTYPE_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t, svn_argnum_obj0);
11788
14043
    if (tmp == NULL || PyErr_Occurred()) {
11789
14044
      SWIG_fail;
11790
14045
    }
11851
14106
  return SWIG_Py_Void();
11852
14107
}
11853
14108
 
 
14109
SWIGINTERN PyObject *svn_fs_upgrade_notify_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
14110
  PyObject *obj;
 
14111
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
14112
  SWIG_TypeNewClientData(SWIGTYPE_p_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t, SWIG_NewClientData(obj));
 
14113
  return SWIG_Py_Void();
 
14114
}
 
14115
 
11854
14116
SWIGINTERN PyObject *svn_fs_progress_notify_func_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11855
14117
  PyObject *obj;
11856
14118
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
11858
14120
  return SWIG_Py_Void();
11859
14121
}
11860
14122
 
 
14123
SWIGINTERN PyObject *svn_fs_hotcopy_notify_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
14124
  PyObject *obj;
 
14125
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
14126
  SWIG_TypeNewClientData(SWIGTYPE_p_p_f_p_void_long_long_p_apr_pool_t__void, SWIG_NewClientData(obj));
 
14127
  return SWIG_Py_Void();
 
14128
}
 
14129
 
11861
14130
SWIGINTERN PyObject *svn_fs_freeze_func_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11862
14131
  PyObject *obj;
11863
14132
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
11872
14141
  return SWIG_Py_Void();
11873
14142
}
11874
14143
 
 
14144
SWIGINTERN PyObject *svn_fs_lock_callback_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
14145
  PyObject *obj;
 
14146
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
 
14147
  SWIG_TypeNewClientData(SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t, SWIG_NewClientData(obj));
 
14148
  return SWIG_Py_Void();
 
14149
}
 
14150
 
11875
14151
SWIGINTERN PyObject *svn_fs_get_locks_callback_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11876
14152
  PyObject *obj;
11877
14153
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
11891
14167
         { (char *)"svn_fs_version", _wrap_svn_fs_version, METH_VARARGS, (char *)"svn_fs_version() -> svn_version_t const *"},
11892
14168
         { (char *)"svn_fs_initialize", _wrap_svn_fs_initialize, METH_VARARGS, (char *)"svn_fs_initialize(apr_pool_t pool) -> svn_error_t"},
11893
14169
         { (char *)"svn_fs_create", _wrap_svn_fs_create, METH_VARARGS, (char *)"svn_fs_create(char const * path, apr_hash_t fs_config, apr_pool_t pool) -> svn_error_t"},
 
14170
         { (char *)"svn_fs_open2", _wrap_svn_fs_open2, METH_VARARGS, (char *)"svn_fs_open2(char const * path, apr_hash_t fs_config, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
11894
14171
         { (char *)"svn_fs_open", _wrap_svn_fs_open, METH_VARARGS, (char *)"svn_fs_open(char const * path, apr_hash_t fs_config, apr_pool_t pool) -> svn_error_t"},
 
14172
         { (char *)"svn_fs_upgrade2", _wrap_svn_fs_upgrade2, METH_VARARGS, (char *)"\n"
 
14173
                "svn_fs_upgrade2(char const * path, svn_fs_upgrade_notify_t notify_func, void * notify_baton, svn_cancel_func_t cancel_func, \n"
 
14174
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
 
14175
                ""},
11895
14176
         { (char *)"svn_fs_upgrade", _wrap_svn_fs_upgrade, METH_VARARGS, (char *)"svn_fs_upgrade(char const * path, apr_pool_t pool) -> svn_error_t"},
11896
14177
         { (char *)"svn_fs_type", _wrap_svn_fs_type, METH_VARARGS, (char *)"svn_fs_type(char const * path, apr_pool_t pool) -> svn_error_t"},
11897
14178
         { (char *)"svn_fs_path", _wrap_svn_fs_path, METH_VARARGS, (char *)"svn_fs_path(svn_fs_t * fs, apr_pool_t pool) -> char const *"},
11898
14179
         { (char *)"svn_fs_config", _wrap_svn_fs_config, METH_VARARGS, (char *)"svn_fs_config(svn_fs_t * fs, apr_pool_t pool) -> apr_hash_t"},
11899
14180
         { (char *)"svn_fs_delete_fs", _wrap_svn_fs_delete_fs, METH_VARARGS, (char *)"svn_fs_delete_fs(char const * path, apr_pool_t pool) -> svn_error_t"},
 
14181
         { (char *)"svn_fs_hotcopy3", _wrap_svn_fs_hotcopy3, METH_VARARGS, (char *)"\n"
 
14182
                "svn_fs_hotcopy3(char const * src_path, char const * dest_path, svn_boolean_t clean, svn_boolean_t incremental, \n"
 
14183
                "    svn_fs_hotcopy_notify_t notify_func, void * notify_baton, svn_cancel_func_t cancel_func, \n"
 
14184
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
 
14185
                ""},
11900
14186
         { (char *)"svn_fs_hotcopy2", _wrap_svn_fs_hotcopy2, METH_VARARGS, (char *)"\n"
11901
14187
                "svn_fs_hotcopy2(char const * src_path, char const * dest_path, svn_boolean_t clean, svn_boolean_t incremental, \n"
11902
14188
                "    svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t\n"
11960
14246
         { (char *)"svn_fs_path_change2_t_copyfrom_rev_get", _wrap_svn_fs_path_change2_t_copyfrom_rev_get, METH_VARARGS, (char *)"svn_fs_path_change2_t_copyfrom_rev_get(svn_fs_path_change2_t self) -> svn_revnum_t"},
11961
14247
         { (char *)"svn_fs_path_change2_t_copyfrom_path_set", _wrap_svn_fs_path_change2_t_copyfrom_path_set, METH_VARARGS, (char *)"svn_fs_path_change2_t_copyfrom_path_set(svn_fs_path_change2_t self, char const * copyfrom_path)"},
11962
14248
         { (char *)"svn_fs_path_change2_t_copyfrom_path_get", _wrap_svn_fs_path_change2_t_copyfrom_path_get, METH_VARARGS, (char *)"svn_fs_path_change2_t_copyfrom_path_get(svn_fs_path_change2_t self) -> char const *"},
 
14249
         { (char *)"svn_fs_path_change2_t_mergeinfo_mod_set", _wrap_svn_fs_path_change2_t_mergeinfo_mod_set, METH_VARARGS, (char *)"svn_fs_path_change2_t_mergeinfo_mod_set(svn_fs_path_change2_t self, svn_tristate_t mergeinfo_mod)"},
 
14250
         { (char *)"svn_fs_path_change2_t_mergeinfo_mod_get", _wrap_svn_fs_path_change2_t_mergeinfo_mod_get, METH_VARARGS, (char *)"svn_fs_path_change2_t_mergeinfo_mod_get(svn_fs_path_change2_t self) -> svn_tristate_t"},
11963
14251
         { (char *)"svn_fs_path_change2_t_swigregister", svn_fs_path_change2_t_swigregister, METH_VARARGS, NULL},
11964
14252
         { (char *)"svn_fs_path_change_t_node_rev_id_set", _wrap_svn_fs_path_change_t_node_rev_id_set, METH_VARARGS, (char *)"svn_fs_path_change_t_node_rev_id_set(svn_fs_path_change_t self, svn_fs_id_t const * node_rev_id)"},
11965
14253
         { (char *)"svn_fs_path_change_t_node_rev_id_get", _wrap_svn_fs_path_change_t_node_rev_id_get, METH_VARARGS, (char *)"svn_fs_path_change_t_node_rev_id_get(svn_fs_path_change_t self) -> svn_fs_id_t const *"},
11974
14262
         { (char *)"svn_fs_paths_changed2", _wrap_svn_fs_paths_changed2, METH_VARARGS, (char *)"svn_fs_paths_changed2(svn_fs_root_t * root, apr_pool_t pool) -> svn_error_t"},
11975
14263
         { (char *)"svn_fs_paths_changed", _wrap_svn_fs_paths_changed, METH_VARARGS, (char *)"svn_fs_paths_changed(svn_fs_root_t * root, apr_pool_t pool) -> svn_error_t"},
11976
14264
         { (char *)"svn_fs_check_path", _wrap_svn_fs_check_path, METH_VARARGS, (char *)"svn_fs_check_path(svn_fs_root_t * root, char const * path, apr_pool_t pool) -> svn_error_t"},
 
14265
         { (char *)"svn_fs_node_history2", _wrap_svn_fs_node_history2, METH_VARARGS, (char *)"svn_fs_node_history2(svn_fs_root_t * root, char const * path, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
11977
14266
         { (char *)"svn_fs_node_history", _wrap_svn_fs_node_history, METH_VARARGS, (char *)"svn_fs_node_history(svn_fs_root_t * root, char const * path, apr_pool_t pool) -> svn_error_t"},
 
14267
         { (char *)"svn_fs_history_prev2", _wrap_svn_fs_history_prev2, METH_VARARGS, (char *)"svn_fs_history_prev2(svn_fs_history_t * history, svn_boolean_t cross_copies, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
11978
14268
         { (char *)"svn_fs_history_prev", _wrap_svn_fs_history_prev, METH_VARARGS, (char *)"svn_fs_history_prev(svn_fs_history_t * history, svn_boolean_t cross_copies, apr_pool_t pool) -> svn_error_t"},
11979
14269
         { (char *)"svn_fs_history_location", _wrap_svn_fs_history_location, METH_VARARGS, (char *)"svn_fs_history_location(svn_fs_history_t * history, apr_pool_t pool) -> svn_error_t"},
11980
14270
         { (char *)"svn_fs_is_dir", _wrap_svn_fs_is_dir, METH_VARARGS, (char *)"svn_fs_is_dir(svn_fs_root_t * root, char const * path, apr_pool_t pool) -> svn_error_t"},
11981
14271
         { (char *)"svn_fs_is_file", _wrap_svn_fs_is_file, METH_VARARGS, (char *)"svn_fs_is_file(svn_fs_root_t * root, char const * path, apr_pool_t pool) -> svn_error_t"},
11982
14272
         { (char *)"svn_fs_node_id", _wrap_svn_fs_node_id, METH_VARARGS, (char *)"svn_fs_node_id(svn_fs_root_t * root, char const * path, apr_pool_t pool) -> svn_error_t"},
 
14273
         { (char *)"svn_fs_node_relation", _wrap_svn_fs_node_relation, METH_VARARGS, (char *)"\n"
 
14274
                "svn_fs_node_relation(svn_fs_node_relation_t * relation, svn_fs_root_t * root_a, char const * path_a, svn_fs_root_t * root_b, \n"
 
14275
                "    char const * path_b, apr_pool_t scratch_pool) -> svn_error_t\n"
 
14276
                ""},
11983
14277
         { (char *)"svn_fs_node_created_rev", _wrap_svn_fs_node_created_rev, METH_VARARGS, (char *)"svn_fs_node_created_rev(svn_fs_root_t * root, char const * path, apr_pool_t pool) -> svn_error_t"},
11984
14278
         { (char *)"svn_fs_node_origin_rev", _wrap_svn_fs_node_origin_rev, METH_VARARGS, (char *)"svn_fs_node_origin_rev(svn_fs_root_t * root, char const * path, apr_pool_t pool) -> svn_error_t"},
11985
14279
         { (char *)"svn_fs_node_created_path", _wrap_svn_fs_node_created_path, METH_VARARGS, (char *)"svn_fs_node_created_path(svn_fs_root_t * root, char const * path, apr_pool_t pool) -> svn_error_t"},
11986
14280
         { (char *)"svn_fs_node_prop", _wrap_svn_fs_node_prop, METH_VARARGS, (char *)"svn_fs_node_prop(svn_fs_root_t * root, char const * path, char const * propname, apr_pool_t pool) -> svn_error_t"},
11987
14281
         { (char *)"svn_fs_node_proplist", _wrap_svn_fs_node_proplist, METH_VARARGS, (char *)"svn_fs_node_proplist(svn_fs_root_t * root, char const * path, apr_pool_t pool) -> svn_error_t"},
 
14282
         { (char *)"svn_fs_node_has_props", _wrap_svn_fs_node_has_props, METH_VARARGS, (char *)"svn_fs_node_has_props(svn_fs_root_t * root, char const * path, apr_pool_t scratch_pool) -> svn_error_t"},
11988
14283
         { (char *)"svn_fs_change_node_prop", _wrap_svn_fs_change_node_prop, METH_VARARGS, (char *)"\n"
11989
14284
                "svn_fs_change_node_prop(svn_fs_root_t * root, char const * path, char const * name, svn_string_t const * value, \n"
11990
14285
                "    apr_pool_t pool) -> svn_error_t\n"
11991
14286
                ""},
 
14287
         { (char *)"svn_fs_props_different", _wrap_svn_fs_props_different, METH_VARARGS, (char *)"\n"
 
14288
                "svn_fs_props_different(svn_fs_root_t * root1, char const * path1, svn_fs_root_t * root2, char const * path2, \n"
 
14289
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
 
14290
                ""},
11992
14291
         { (char *)"svn_fs_props_changed", _wrap_svn_fs_props_changed, METH_VARARGS, (char *)"\n"
11993
14292
                "svn_fs_props_changed(svn_fs_root_t * root1, char const * path1, svn_fs_root_t * root2, char const * path2, \n"
11994
14293
                "    apr_pool_t pool) -> svn_error_t\n"
12017
14316
         { (char *)"svn_fs_dirent_t_kind_get", _wrap_svn_fs_dirent_t_kind_get, METH_VARARGS, (char *)"svn_fs_dirent_t_kind_get(svn_fs_dirent_t self) -> svn_node_kind_t"},
12018
14317
         { (char *)"svn_fs_dirent_t_swigregister", svn_fs_dirent_t_swigregister, METH_VARARGS, NULL},
12019
14318
         { (char *)"svn_fs_dir_entries", _wrap_svn_fs_dir_entries, METH_VARARGS, (char *)"svn_fs_dir_entries(svn_fs_root_t * root, char const * path, apr_pool_t pool) -> svn_error_t"},
 
14319
         { (char *)"svn_fs_dir_optimal_order", _wrap_svn_fs_dir_optimal_order, METH_VARARGS, (char *)"svn_fs_dir_optimal_order(svn_fs_root_t * root, apr_hash_t entries, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
12020
14320
         { (char *)"svn_fs_make_dir", _wrap_svn_fs_make_dir, METH_VARARGS, (char *)"svn_fs_make_dir(svn_fs_root_t * root, char const * path, apr_pool_t pool) -> svn_error_t"},
12021
14321
         { (char *)"svn_fs_delete", _wrap_svn_fs_delete, METH_VARARGS, (char *)"svn_fs_delete(svn_fs_root_t * root, char const * path, apr_pool_t pool) -> svn_error_t"},
12022
14322
         { (char *)"svn_fs_copy", _wrap_svn_fs_copy, METH_VARARGS, (char *)"\n"
12041
14341
                "    apr_pool_t pool) -> svn_error_t\n"
12042
14342
                ""},
12043
14343
         { (char *)"svn_fs_apply_text", _wrap_svn_fs_apply_text, METH_VARARGS, (char *)"svn_fs_apply_text(svn_fs_root_t * root, char const * path, char const * result_checksum, apr_pool_t pool) -> svn_error_t"},
 
14344
         { (char *)"svn_fs_contents_different", _wrap_svn_fs_contents_different, METH_VARARGS, (char *)"\n"
 
14345
                "svn_fs_contents_different(svn_fs_root_t * root1, char const * path1, svn_fs_root_t * root2, char const * path2, \n"
 
14346
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
 
14347
                ""},
12044
14348
         { (char *)"svn_fs_contents_changed", _wrap_svn_fs_contents_changed, METH_VARARGS, (char *)"\n"
12045
14349
                "svn_fs_contents_changed(svn_fs_root_t * root1, char const * path1, svn_fs_root_t * root2, char const * path2, \n"
12046
14350
                "    apr_pool_t pool) -> svn_error_t\n"
12047
14351
                ""},
12048
14352
         { (char *)"svn_fs_youngest_rev", _wrap_svn_fs_youngest_rev, METH_VARARGS, (char *)"svn_fs_youngest_rev(svn_fs_t * fs, apr_pool_t pool) -> svn_error_t"},
 
14353
         { (char *)"svn_fs_info_format", _wrap_svn_fs_info_format, METH_VARARGS, (char *)"svn_fs_info_format(svn_fs_t * fs, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
 
14354
         { (char *)"svn_fs_info_config_files", _wrap_svn_fs_info_config_files, METH_VARARGS, (char *)"svn_fs_info_config_files(svn_fs_t * fs, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
12049
14355
         { (char *)"svn_fs_deltify_revision", _wrap_svn_fs_deltify_revision, METH_VARARGS, (char *)"svn_fs_deltify_revision(svn_fs_t * fs, svn_revnum_t revision, apr_pool_t pool) -> svn_error_t"},
12050
14356
         { (char *)"svn_fs_revision_prop", _wrap_svn_fs_revision_prop, METH_VARARGS, (char *)"svn_fs_revision_prop(svn_fs_t * fs, svn_revnum_t rev, char const * propname, apr_pool_t pool) -> svn_error_t"},
12051
14357
         { (char *)"svn_fs_revision_proplist", _wrap_svn_fs_revision_proplist, METH_VARARGS, (char *)"svn_fs_revision_proplist(svn_fs_t * fs, svn_revnum_t rev, apr_pool_t pool) -> svn_error_t"},
12060
14366
                ""},
12061
14367
         { (char *)"svn_fs_get_uuid", _wrap_svn_fs_get_uuid, METH_VARARGS, (char *)"svn_fs_get_uuid(svn_fs_t * fs, apr_pool_t pool) -> svn_error_t"},
12062
14368
         { (char *)"svn_fs_set_uuid", _wrap_svn_fs_set_uuid, METH_VARARGS, (char *)"svn_fs_set_uuid(svn_fs_t * fs, char const * uuid, apr_pool_t pool) -> svn_error_t"},
 
14369
         { (char *)"svn_fs_lock_target_create", _wrap_svn_fs_lock_target_create, METH_VARARGS, (char *)"svn_fs_lock_target_create(char const * token, svn_revnum_t current_rev, apr_pool_t result_pool) -> svn_fs_lock_target_t *"},
 
14370
         { (char *)"svn_fs_lock_target_set_token", _wrap_svn_fs_lock_target_set_token, METH_VARARGS, (char *)"svn_fs_lock_target_set_token(svn_fs_lock_target_t * target, char const * token)"},
 
14371
         { (char *)"svn_fs_lock_many", _wrap_svn_fs_lock_many, METH_VARARGS, (char *)"\n"
 
14372
                "svn_fs_lock_many(svn_fs_t * fs, apr_hash_t lock_targets, char const * comment, svn_boolean_t is_dav_comment, \n"
 
14373
                "    apr_time_t expiration_date, svn_boolean_t steal_lock, svn_fs_lock_callback_t lock_callback, \n"
 
14374
                "    apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t\n"
 
14375
                ""},
12063
14376
         { (char *)"svn_fs_lock", _wrap_svn_fs_lock, METH_VARARGS, (char *)"\n"
12064
14377
                "svn_fs_lock(svn_fs_t * fs, char const * path, char const * token, char const * comment, svn_boolean_t is_dav_comment, \n"
12065
14378
                "    apr_time_t expiration_date, svn_revnum_t current_rev, \n"
12066
14379
                "    svn_boolean_t steal_lock, apr_pool_t pool) -> svn_error_t\n"
12067
14380
                ""},
12068
14381
         { (char *)"svn_fs_generate_lock_token", _wrap_svn_fs_generate_lock_token, METH_VARARGS, (char *)"svn_fs_generate_lock_token(svn_fs_t * fs, apr_pool_t pool) -> svn_error_t"},
 
14382
         { (char *)"svn_fs_unlock_many", _wrap_svn_fs_unlock_many, METH_VARARGS, (char *)"\n"
 
14383
                "svn_fs_unlock_many(svn_fs_t * fs, apr_hash_t unlock_targets, svn_boolean_t break_lock, svn_fs_lock_callback_t lock_callback, \n"
 
14384
                "    apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t\n"
 
14385
                ""},
12069
14386
         { (char *)"svn_fs_unlock", _wrap_svn_fs_unlock, METH_VARARGS, (char *)"svn_fs_unlock(svn_fs_t * fs, char const * path, char const * token, svn_boolean_t break_lock, apr_pool_t pool) -> svn_error_t"},
12070
14387
         { (char *)"svn_fs_get_lock", _wrap_svn_fs_get_lock, METH_VARARGS, (char *)"svn_fs_get_lock(svn_fs_t * fs, char const * path, apr_pool_t pool) -> svn_error_t"},
12071
14388
         { (char *)"svn_fs_get_locks2", _wrap_svn_fs_get_locks2, METH_VARARGS, (char *)"\n"
12084
14401
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
12085
14402
                ""},
12086
14403
         { (char *)"svn_fs_verify_root", _wrap_svn_fs_verify_root, METH_VARARGS, (char *)"svn_fs_verify_root(svn_fs_root_t * root, apr_pool_t scratch_pool) -> svn_error_t"},
 
14404
         { (char *)"svn_fs_fsfs_info_t_fs_type_set", _wrap_svn_fs_fsfs_info_t_fs_type_set, METH_VARARGS, (char *)"svn_fs_fsfs_info_t_fs_type_set(svn_fs_fsfs_info_t self, char const * fs_type)"},
 
14405
         { (char *)"svn_fs_fsfs_info_t_fs_type_get", _wrap_svn_fs_fsfs_info_t_fs_type_get, METH_VARARGS, (char *)"svn_fs_fsfs_info_t_fs_type_get(svn_fs_fsfs_info_t self) -> char const *"},
 
14406
         { (char *)"svn_fs_fsfs_info_t_shard_size_set", _wrap_svn_fs_fsfs_info_t_shard_size_set, METH_VARARGS, (char *)"svn_fs_fsfs_info_t_shard_size_set(svn_fs_fsfs_info_t self, int shard_size)"},
 
14407
         { (char *)"svn_fs_fsfs_info_t_shard_size_get", _wrap_svn_fs_fsfs_info_t_shard_size_get, METH_VARARGS, (char *)"svn_fs_fsfs_info_t_shard_size_get(svn_fs_fsfs_info_t self) -> int"},
 
14408
         { (char *)"svn_fs_fsfs_info_t_min_unpacked_rev_set", _wrap_svn_fs_fsfs_info_t_min_unpacked_rev_set, METH_VARARGS, (char *)"svn_fs_fsfs_info_t_min_unpacked_rev_set(svn_fs_fsfs_info_t self, svn_revnum_t min_unpacked_rev)"},
 
14409
         { (char *)"svn_fs_fsfs_info_t_min_unpacked_rev_get", _wrap_svn_fs_fsfs_info_t_min_unpacked_rev_get, METH_VARARGS, (char *)"svn_fs_fsfs_info_t_min_unpacked_rev_get(svn_fs_fsfs_info_t self) -> svn_revnum_t"},
 
14410
         { (char *)"svn_fs_fsfs_info_t_log_addressing_set", _wrap_svn_fs_fsfs_info_t_log_addressing_set, METH_VARARGS, (char *)"svn_fs_fsfs_info_t_log_addressing_set(svn_fs_fsfs_info_t self, svn_boolean_t log_addressing)"},
 
14411
         { (char *)"svn_fs_fsfs_info_t_log_addressing_get", _wrap_svn_fs_fsfs_info_t_log_addressing_get, METH_VARARGS, (char *)"svn_fs_fsfs_info_t_log_addressing_get(svn_fs_fsfs_info_t self) -> svn_boolean_t"},
 
14412
         { (char *)"svn_fs_fsfs_info_t_swigregister", svn_fs_fsfs_info_t_swigregister, METH_VARARGS, NULL},
 
14413
         { (char *)"svn_fs_fsx_info_t_fs_type_set", _wrap_svn_fs_fsx_info_t_fs_type_set, METH_VARARGS, (char *)"svn_fs_fsx_info_t_fs_type_set(svn_fs_fsx_info_t self, char const * fs_type)"},
 
14414
         { (char *)"svn_fs_fsx_info_t_fs_type_get", _wrap_svn_fs_fsx_info_t_fs_type_get, METH_VARARGS, (char *)"svn_fs_fsx_info_t_fs_type_get(svn_fs_fsx_info_t self) -> char const *"},
 
14415
         { (char *)"svn_fs_fsx_info_t_shard_size_set", _wrap_svn_fs_fsx_info_t_shard_size_set, METH_VARARGS, (char *)"svn_fs_fsx_info_t_shard_size_set(svn_fs_fsx_info_t self, int shard_size)"},
 
14416
         { (char *)"svn_fs_fsx_info_t_shard_size_get", _wrap_svn_fs_fsx_info_t_shard_size_get, METH_VARARGS, (char *)"svn_fs_fsx_info_t_shard_size_get(svn_fs_fsx_info_t self) -> int"},
 
14417
         { (char *)"svn_fs_fsx_info_t_min_unpacked_rev_set", _wrap_svn_fs_fsx_info_t_min_unpacked_rev_set, METH_VARARGS, (char *)"svn_fs_fsx_info_t_min_unpacked_rev_set(svn_fs_fsx_info_t self, svn_revnum_t min_unpacked_rev)"},
 
14418
         { (char *)"svn_fs_fsx_info_t_min_unpacked_rev_get", _wrap_svn_fs_fsx_info_t_min_unpacked_rev_get, METH_VARARGS, (char *)"svn_fs_fsx_info_t_min_unpacked_rev_get(svn_fs_fsx_info_t self) -> svn_revnum_t"},
 
14419
         { (char *)"svn_fs_fsx_info_t_swigregister", svn_fs_fsx_info_t_swigregister, METH_VARARGS, NULL},
 
14420
         { (char *)"svn_fs_info_placeholder_t_fs_type_set", _wrap_svn_fs_info_placeholder_t_fs_type_set, METH_VARARGS, (char *)"svn_fs_info_placeholder_t_fs_type_set(svn_fs_info_placeholder_t self, char const * fs_type)"},
 
14421
         { (char *)"svn_fs_info_placeholder_t_fs_type_get", _wrap_svn_fs_info_placeholder_t_fs_type_get, METH_VARARGS, (char *)"svn_fs_info_placeholder_t_fs_type_get(svn_fs_info_placeholder_t self) -> char const *"},
 
14422
         { (char *)"svn_fs_info_placeholder_t_swigregister", svn_fs_info_placeholder_t_swigregister, METH_VARARGS, NULL},
 
14423
         { (char *)"svn_fs_info", _wrap_svn_fs_info, METH_VARARGS, (char *)"svn_fs_info(svn_fs_t * fs, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"},
 
14424
         { (char *)"svn_fs_info_dup", _wrap_svn_fs_info_dup, METH_VARARGS, (char *)"svn_fs_info_dup(void const * info, apr_pool_t result_pool, apr_pool_t scratch_pool) -> void *"},
12087
14425
         { (char *)"svn_fs_t_swigregister", svn_fs_t_swigregister, METH_VARARGS, NULL},
12088
14426
         { (char *)"svn_fs_access_t_swigregister", svn_fs_access_t_swigregister, METH_VARARGS, NULL},
12089
14427
         { (char *)"svn_fs_id_t_swigregister", svn_fs_id_t_swigregister, METH_VARARGS, NULL},
12090
14428
         { (char *)"svn_fs_txn_t_swigregister", svn_fs_txn_t_swigregister, METH_VARARGS, NULL},
12091
14429
         { (char *)"svn_fs_root_t_swigregister", svn_fs_root_t_swigregister, METH_VARARGS, NULL},
12092
14430
         { (char *)"svn_fs_history_t_swigregister", svn_fs_history_t_swigregister, METH_VARARGS, NULL},
 
14431
         { (char *)"svn_fs_lock_target_t_swigregister", svn_fs_lock_target_t_swigregister, METH_VARARGS, NULL},
12093
14432
         { (char *)"svn_fs_invoke_warning_callback", _wrap_svn_fs_invoke_warning_callback, METH_VARARGS, (char *)"svn_fs_invoke_warning_callback(svn_fs_warning_callback_t _obj, void * baton, svn_error_t err)"},
 
14433
         { (char *)"svn_fs_invoke_upgrade_notify", _wrap_svn_fs_invoke_upgrade_notify, METH_VARARGS, (char *)"\n"
 
14434
                "svn_fs_invoke_upgrade_notify(svn_fs_upgrade_notify_t _obj, void * baton, apr_uint64_t number, svn_fs_upgrade_notify_action_t action, \n"
 
14435
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
 
14436
                ""},
12094
14437
         { (char *)"svn_fs_invoke_progress_notify_func", _wrap_svn_fs_invoke_progress_notify_func, METH_VARARGS, (char *)"svn_fs_invoke_progress_notify_func(svn_fs_progress_notify_func_t _obj, svn_revnum_t revision, void * baton, apr_pool_t pool)"},
 
14438
         { (char *)"svn_fs_invoke_hotcopy_notify", _wrap_svn_fs_invoke_hotcopy_notify, METH_VARARGS, (char *)"\n"
 
14439
                "svn_fs_invoke_hotcopy_notify(svn_fs_hotcopy_notify_t _obj, void * baton, svn_revnum_t start_revision, svn_revnum_t end_revision, \n"
 
14440
                "    apr_pool_t scratch_pool)\n"
 
14441
                ""},
12095
14442
         { (char *)"svn_fs_invoke_freeze_func", _wrap_svn_fs_invoke_freeze_func, METH_VARARGS, (char *)"svn_fs_invoke_freeze_func(svn_fs_freeze_func_t _obj, void * baton, apr_pool_t pool) -> svn_error_t"},
12096
14443
         { (char *)"svn_fs_invoke_process_contents_func", _wrap_svn_fs_invoke_process_contents_func, METH_VARARGS, (char *)"\n"
12097
14444
                "svn_fs_invoke_process_contents_func(svn_fs_process_contents_func_t _obj, unsigned char const * contents, apr_size_t len, \n"
12098
14445
                "    void * baton, apr_pool_t scratch_pool) -> svn_error_t\n"
12099
14446
                ""},
 
14447
         { (char *)"svn_fs_invoke_lock_callback", _wrap_svn_fs_invoke_lock_callback, METH_VARARGS, (char *)"\n"
 
14448
                "svn_fs_invoke_lock_callback(svn_fs_lock_callback_t _obj, void * baton, char const * path, svn_lock_t lock, svn_error_t fs_err, \n"
 
14449
                "    apr_pool_t scratch_pool) -> svn_error_t\n"
 
14450
                ""},
12100
14451
         { (char *)"svn_fs_invoke_get_locks_callback", _wrap_svn_fs_invoke_get_locks_callback, METH_VARARGS, (char *)"svn_fs_invoke_get_locks_callback(svn_fs_get_locks_callback_t _obj, void * baton, svn_lock_t lock, apr_pool_t pool) -> svn_error_t"},
12101
14452
         { (char *)"svn_fs_invoke_pack_notify", _wrap_svn_fs_invoke_pack_notify, METH_VARARGS, (char *)"\n"
12102
14453
                "svn_fs_invoke_pack_notify(svn_fs_pack_notify_t _obj, void * baton, apr_int64_t shard, svn_fs_pack_notify_action_t action, \n"
12103
14454
                "    apr_pool_t pool) -> svn_error_t\n"
12104
14455
                ""},
12105
14456
         { (char *)"svn_fs_warning_callback_t_swigregister", svn_fs_warning_callback_t_swigregister, METH_VARARGS, NULL},
 
14457
         { (char *)"svn_fs_upgrade_notify_t_swigregister", svn_fs_upgrade_notify_t_swigregister, METH_VARARGS, NULL},
12106
14458
         { (char *)"svn_fs_progress_notify_func_t_swigregister", svn_fs_progress_notify_func_t_swigregister, METH_VARARGS, NULL},
 
14459
         { (char *)"svn_fs_hotcopy_notify_t_swigregister", svn_fs_hotcopy_notify_t_swigregister, METH_VARARGS, NULL},
12107
14460
         { (char *)"svn_fs_freeze_func_t_swigregister", svn_fs_freeze_func_t_swigregister, METH_VARARGS, NULL},
12108
14461
         { (char *)"svn_fs_process_contents_func_t_swigregister", svn_fs_process_contents_func_t_swigregister, METH_VARARGS, NULL},
 
14462
         { (char *)"svn_fs_lock_callback_t_swigregister", svn_fs_lock_callback_t_swigregister, METH_VARARGS, NULL},
12109
14463
         { (char *)"svn_fs_get_locks_callback_t_swigregister", svn_fs_get_locks_callback_t_swigregister, METH_VARARGS, NULL},
12110
14464
         { (char *)"svn_fs_pack_notify_t_swigregister", svn_fs_pack_notify_t_swigregister, METH_VARARGS, NULL},
12111
14465
         { NULL, NULL, 0, NULL }
12119
14473
static swig_type_info _swigt__p_apr_int32_t = {"_p_apr_int32_t", "apr_int32_t *|time_t *", 0, 0, (void*)0, 0};
12120
14474
static swig_type_info _swigt__p_apr_int64_t = {"_p_apr_int64_t", "apr_int64_t *|svn_filesize_t *|apr_time_t *", 0, 0, (void*)0, 0};
12121
14475
static swig_type_info _swigt__p_apr_pool_t = {"_p_apr_pool_t", "apr_pool_t *", 0, 0, (void*)0, 0};
 
14476
static swig_type_info _swigt__p_apr_uint64_t = {"_p_apr_uint64_t", "apr_uint64_t *", 0, 0, (void*)0, 0};
12122
14477
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
12123
14478
static swig_type_info _swigt__p_f_long_p_void_p_apr_pool_t__void = {"_p_f_long_p_void_p_apr_pool_t__void", "void (*)(long,void *,apr_pool_t *)|svn_fs_progress_notify_func_t", 0, 0, (void*)0, 0};
12124
14479
static swig_type_info _swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t", "svn_opt_subcommand_t *|struct svn_error_t *(*)(apr_getopt_t *,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
12125
14480
static swig_type_info _swigt__p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t", "svn_fs_process_contents_func_t|struct svn_error_t *(*)(unsigned char const *,apr_size_t,void *,apr_pool_t *)", 0, 0, (void*)0, 0};
12126
14481
static swig_type_info _swigt__p_f_p_void__p_svn_error_t = {"_p_f_p_void__p_svn_error_t", "svn_cancel_func_t|struct svn_error_t *(*)(void *)", 0, 0, (void*)0, 0};
12127
14482
static swig_type_info _swigt__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,apr_int64_t,svn_fs_pack_notify_action_t,apr_pool_t *)|svn_fs_pack_notify_t", 0, 0, (void*)0, 0};
 
14483
static swig_type_info _swigt__p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,apr_uint64_t,svn_fs_upgrade_notify_action_t,apr_pool_t *)|svn_fs_upgrade_notify_t", 0, 0, (void*)0, 0};
 
14484
static swig_type_info _swigt__p_f_p_void_long_long_p_apr_pool_t__void = {"_p_f_p_void_long_long_p_apr_pool_t__void", "void (*)(void *,long,long,apr_pool_t *)|svn_fs_hotcopy_notify_t", 0, 0, (void*)0, 0};
12128
14485
static swig_type_info _swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,apr_pool_t *)|svn_fs_freeze_func_t", 0, 0, (void*)0, 0};
 
14486
static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,char const *,svn_lock_t const *,svn_error_t *,apr_pool_t *)|svn_fs_lock_callback_t", 0, 0, (void*)0, 0};
12129
14487
static swig_type_info _swigt__p_f_p_void_p_struct_svn_error_t__void = {"_p_f_p_void_p_struct_svn_error_t__void", "void (*)(void *,struct svn_error_t *)|svn_fs_warning_callback_t", 0, 0, (void*)0, 0};
12130
14488
static swig_type_info _swigt__p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t = {"_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(*)(void *,svn_lock_t *,apr_pool_t *)|svn_fs_get_locks_callback_t", 0, 0, (void*)0, 0};
12131
14489
static swig_type_info _swigt__p_int = {"_p_int", "int *|svn_boolean_t *|apr_status_t *", 0, 0, (void*)0, 0};
12137
14495
static swig_type_info _swigt__p_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(**)(unsigned char const *,apr_size_t,void *,apr_pool_t *)|svn_fs_process_contents_func_t *", 0, 0, (void*)0, 0};
12138
14496
static swig_type_info _swigt__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t = {"_p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t", "svn_txdelta_window_handler_t *|struct svn_error_t *(**)(svn_txdelta_window_t *,void *)", 0, 0, (void*)0, 0};
12139
14497
static swig_type_info _swigt__p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(**)(void *,apr_int64_t,svn_fs_pack_notify_action_t,apr_pool_t *)|svn_fs_pack_notify_t *", 0, 0, (void*)0, 0};
 
14498
static swig_type_info _swigt__p_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(**)(void *,apr_uint64_t,svn_fs_upgrade_notify_action_t,apr_pool_t *)|svn_fs_upgrade_notify_t *", 0, 0, (void*)0, 0};
 
14499
static swig_type_info _swigt__p_p_f_p_void_long_long_p_apr_pool_t__void = {"_p_p_f_p_void_long_long_p_apr_pool_t__void", "void (**)(void *,long,long,apr_pool_t *)|svn_fs_hotcopy_notify_t *", 0, 0, (void*)0, 0};
12140
14500
static swig_type_info _swigt__p_p_f_p_void_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_void_p_apr_pool_t__p_svn_error_t", "struct svn_error_t *(**)(void *,apr_pool_t *)|svn_fs_freeze_func_t *", 0, 0, (void*)0, 0};
 
14501
static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t", "svn_fs_lock_callback_t *|struct svn_error_t *(**)(void *,char const *,svn_lock_t const *,svn_error_t *,apr_pool_t *)", 0, 0, (void*)0, 0};
12141
14502
static swig_type_info _swigt__p_p_f_p_void_p_struct_svn_error_t__void = {"_p_p_f_p_void_p_struct_svn_error_t__void", "void (**)(void *,struct svn_error_t *)|svn_fs_warning_callback_t *", 0, 0, (void*)0, 0};
12142
14503
static swig_type_info _swigt__p_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t = {"_p_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t", "svn_fs_get_locks_callback_t *|struct svn_error_t *(**)(void *,svn_lock_t *,apr_pool_t *)", 0, 0, (void*)0, 0};
12143
14504
static swig_type_info _swigt__p_p_svn_checksum_t = {"_p_p_svn_checksum_t", "struct svn_checksum_t **|svn_checksum_t **", 0, 0, (void*)0, 0};
12144
14505
static swig_type_info _swigt__p_p_svn_fs_access_t = {"_p_p_svn_fs_access_t", "struct svn_fs_access_t **|svn_fs_access_t **", 0, 0, (void*)0, 0};
12145
14506
static swig_type_info _swigt__p_p_svn_fs_history_t = {"_p_p_svn_fs_history_t", "struct svn_fs_history_t **|svn_fs_history_t **", 0, 0, (void*)0, 0};
12146
14507
static swig_type_info _swigt__p_p_svn_fs_id_t = {"_p_p_svn_fs_id_t", "struct svn_fs_id_t **|svn_fs_id_t **", 0, 0, (void*)0, 0};
 
14508
static swig_type_info _swigt__p_p_svn_fs_info_placeholder_t = {"_p_p_svn_fs_info_placeholder_t", "struct svn_fs_info_placeholder_t **|svn_fs_info_placeholder_t **", 0, 0, (void*)0, 0};
12147
14509
static swig_type_info _swigt__p_p_svn_fs_root_t = {"_p_p_svn_fs_root_t", "struct svn_fs_root_t **|svn_fs_root_t **", 0, 0, (void*)0, 0};
12148
14510
static swig_type_info _swigt__p_p_svn_fs_t = {"_p_p_svn_fs_t", "struct svn_fs_t **|svn_fs_t **", 0, 0, (void*)0, 0};
12149
14511
static swig_type_info _swigt__p_p_svn_fs_txn_t = {"_p_p_svn_fs_txn_t", "struct svn_fs_txn_t **|svn_fs_txn_t **", 0, 0, (void*)0, 0};
12151
14513
static swig_type_info _swigt__p_p_svn_stream_t = {"_p_p_svn_stream_t", "struct svn_stream_t **|svn_stream_t **", 0, 0, (void*)0, 0};
12152
14514
static swig_type_info _swigt__p_p_svn_string_t = {"_p_p_svn_string_t", "struct svn_string_t **|svn_string_t **", 0, 0, (void*)0, 0};
12153
14515
static swig_type_info _swigt__p_p_svn_txdelta_stream_t = {"_p_p_svn_txdelta_stream_t", "struct svn_txdelta_stream_t **|svn_txdelta_stream_t **", 0, 0, (void*)0, 0};
 
14516
static swig_type_info _swigt__p_p_svn_version_t = {"_p_p_svn_version_t", "struct svn_version_t **|svn_version_t **", 0, 0, (void*)0, 0};
12154
14517
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
12155
14518
static swig_type_info _swigt__p_svn_auth_baton_t = {"_p_svn_auth_baton_t", "struct svn_auth_baton_t *|svn_auth_baton_t *", 0, 0, (void*)0, 0};
12156
14519
static swig_type_info _swigt__p_svn_auth_cred_simple_t = {"_p_svn_auth_cred_simple_t", "struct svn_auth_cred_simple_t *|svn_auth_cred_simple_t *", 0, 0, (void*)0, 0};
12169
14532
static swig_type_info _swigt__p_svn_config_t = {"_p_svn_config_t", "struct svn_config_t *|svn_config_t *", 0, 0, (void*)0, 0};
12170
14533
static swig_type_info _swigt__p_svn_delta_editor_t = {"_p_svn_delta_editor_t", "struct svn_delta_editor_t *|svn_delta_editor_t *", 0, 0, (void*)0, 0};
12171
14534
static swig_type_info _swigt__p_svn_depth_t = {"_p_svn_depth_t", "enum svn_depth_t *|svn_depth_t *", 0, 0, (void*)0, 0};
 
14535
static swig_type_info _swigt__p_svn_diff_hunk_t = {"_p_svn_diff_hunk_t", "svn_diff_hunk_t *", 0, 0, (void*)0, 0};
12172
14536
static swig_type_info _swigt__p_svn_dirent_t = {"_p_svn_dirent_t", "struct svn_dirent_t *|svn_dirent_t *", 0, 0, (void*)0, 0};
12173
14537
static swig_type_info _swigt__p_svn_errno_t = {"_p_svn_errno_t", "enum svn_errno_t *|svn_errno_t *", 0, 0, (void*)0, 0};
12174
14538
static swig_type_info _swigt__p_svn_error_t = {"_p_svn_error_t", "struct svn_error_t *|svn_error_t *", 0, 0, (void*)0, 0};
12175
14539
static swig_type_info _swigt__p_svn_fs_access_t = {"_p_svn_fs_access_t", "struct svn_fs_access_t *|svn_fs_access_t *", 0, 0, (void*)0, 0};
12176
14540
static swig_type_info _swigt__p_svn_fs_dirent_t = {"_p_svn_fs_dirent_t", "struct svn_fs_dirent_t *|svn_fs_dirent_t *", 0, 0, (void*)0, 0};
 
14541
static swig_type_info _swigt__p_svn_fs_fsfs_info_t = {"_p_svn_fs_fsfs_info_t", "struct svn_fs_fsfs_info_t *|svn_fs_fsfs_info_t *", 0, 0, (void*)0, 0};
 
14542
static swig_type_info _swigt__p_svn_fs_fsx_info_t = {"_p_svn_fs_fsx_info_t", "struct svn_fs_fsx_info_t *|svn_fs_fsx_info_t *", 0, 0, (void*)0, 0};
12177
14543
static swig_type_info _swigt__p_svn_fs_history_t = {"_p_svn_fs_history_t", "struct svn_fs_history_t *|svn_fs_history_t *", 0, 0, (void*)0, 0};
12178
14544
static swig_type_info _swigt__p_svn_fs_id_t = {"_p_svn_fs_id_t", "struct svn_fs_id_t *|svn_fs_id_t *", 0, 0, (void*)0, 0};
 
14545
static swig_type_info _swigt__p_svn_fs_info_placeholder_t = {"_p_svn_fs_info_placeholder_t", "struct svn_fs_info_placeholder_t *|svn_fs_info_placeholder_t *", 0, 0, (void*)0, 0};
 
14546
static swig_type_info _swigt__p_svn_fs_lock_target_t = {"_p_svn_fs_lock_target_t", "struct svn_fs_lock_target_t *|svn_fs_lock_target_t *", 0, 0, (void*)0, 0};
 
14547
static swig_type_info _swigt__p_svn_fs_node_relation_t = {"_p_svn_fs_node_relation_t", "enum svn_fs_node_relation_t *|svn_fs_node_relation_t *", 0, 0, (void*)0, 0};
12179
14548
static swig_type_info _swigt__p_svn_fs_pack_notify_action_t = {"_p_svn_fs_pack_notify_action_t", "enum svn_fs_pack_notify_action_t *|svn_fs_pack_notify_action_t *", 0, 0, (void*)0, 0};
12180
14549
static swig_type_info _swigt__p_svn_fs_path_change2_t = {"_p_svn_fs_path_change2_t", "struct svn_fs_path_change2_t *|svn_fs_path_change2_t *", 0, 0, (void*)0, 0};
12181
14550
static swig_type_info _swigt__p_svn_fs_path_change_kind_t = {"_p_svn_fs_path_change_kind_t", "enum svn_fs_path_change_kind_t *|svn_fs_path_change_kind_t *", 0, 0, (void*)0, 0};
12183
14552
static swig_type_info _swigt__p_svn_fs_root_t = {"_p_svn_fs_root_t", "struct svn_fs_root_t *|svn_fs_root_t *", 0, 0, (void*)0, 0};
12184
14553
static swig_type_info _swigt__p_svn_fs_t = {"_p_svn_fs_t", "struct svn_fs_t *|svn_fs_t *", 0, 0, (void*)0, 0};
12185
14554
static swig_type_info _swigt__p_svn_fs_txn_t = {"_p_svn_fs_txn_t", "struct svn_fs_txn_t *|svn_fs_txn_t *", 0, 0, (void*)0, 0};
 
14555
static swig_type_info _swigt__p_svn_fs_upgrade_notify_action_t = {"_p_svn_fs_upgrade_notify_action_t", "enum svn_fs_upgrade_notify_action_t *|svn_fs_upgrade_notify_action_t *", 0, 0, (void*)0, 0};
12186
14556
static swig_type_info _swigt__p_svn_io_dirent2_t = {"_p_svn_io_dirent2_t", "struct svn_io_dirent2_t *|svn_io_dirent2_t *", 0, 0, (void*)0, 0};
12187
14557
static swig_type_info _swigt__p_svn_io_dirent_t = {"_p_svn_io_dirent_t", "struct svn_io_dirent_t *|svn_io_dirent_t *", 0, 0, (void*)0, 0};
12188
14558
static swig_type_info _swigt__p_svn_io_file_del_t = {"_p_svn_io_file_del_t", "enum svn_io_file_del_t *|svn_io_file_del_t *", 0, 0, (void*)0, 0};
12225
14595
  &_swigt__p_apr_int32_t,
12226
14596
  &_swigt__p_apr_int64_t,
12227
14597
  &_swigt__p_apr_pool_t,
 
14598
  &_swigt__p_apr_uint64_t,
12228
14599
  &_swigt__p_char,
12229
14600
  &_swigt__p_f_long_p_void_p_apr_pool_t__void,
12230
14601
  &_swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t,
12231
14602
  &_swigt__p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t,
12232
14603
  &_swigt__p_f_p_void__p_svn_error_t,
12233
14604
  &_swigt__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t,
 
14605
  &_swigt__p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t,
 
14606
  &_swigt__p_f_p_void_long_long_p_apr_pool_t__void,
12234
14607
  &_swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t,
 
14608
  &_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
12235
14609
  &_swigt__p_f_p_void_p_struct_svn_error_t__void,
12236
14610
  &_swigt__p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t,
12237
14611
  &_swigt__p_int,
12243
14617
  &_swigt__p_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t,
12244
14618
  &_swigt__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
12245
14619
  &_swigt__p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t,
 
14620
  &_swigt__p_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t,
 
14621
  &_swigt__p_p_f_p_void_long_long_p_apr_pool_t__void,
12246
14622
  &_swigt__p_p_f_p_void_p_apr_pool_t__p_svn_error_t,
 
14623
  &_swigt__p_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
12247
14624
  &_swigt__p_p_f_p_void_p_struct_svn_error_t__void,
12248
14625
  &_swigt__p_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t,
12249
14626
  &_swigt__p_p_svn_checksum_t,
12250
14627
  &_swigt__p_p_svn_fs_access_t,
12251
14628
  &_swigt__p_p_svn_fs_history_t,
12252
14629
  &_swigt__p_p_svn_fs_id_t,
 
14630
  &_swigt__p_p_svn_fs_info_placeholder_t,
12253
14631
  &_swigt__p_p_svn_fs_root_t,
12254
14632
  &_swigt__p_p_svn_fs_t,
12255
14633
  &_swigt__p_p_svn_fs_txn_t,
12257
14635
  &_swigt__p_p_svn_stream_t,
12258
14636
  &_swigt__p_p_svn_string_t,
12259
14637
  &_swigt__p_p_svn_txdelta_stream_t,
 
14638
  &_swigt__p_p_svn_version_t,
12260
14639
  &_swigt__p_p_void,
12261
14640
  &_swigt__p_svn_auth_baton_t,
12262
14641
  &_swigt__p_svn_auth_cred_simple_t,
12275
14654
  &_swigt__p_svn_config_t,
12276
14655
  &_swigt__p_svn_delta_editor_t,
12277
14656
  &_swigt__p_svn_depth_t,
 
14657
  &_swigt__p_svn_diff_hunk_t,
12278
14658
  &_swigt__p_svn_dirent_t,
12279
14659
  &_swigt__p_svn_errno_t,
12280
14660
  &_swigt__p_svn_error_t,
12281
14661
  &_swigt__p_svn_fs_access_t,
12282
14662
  &_swigt__p_svn_fs_dirent_t,
 
14663
  &_swigt__p_svn_fs_fsfs_info_t,
 
14664
  &_swigt__p_svn_fs_fsx_info_t,
12283
14665
  &_swigt__p_svn_fs_history_t,
12284
14666
  &_swigt__p_svn_fs_id_t,
 
14667
  &_swigt__p_svn_fs_info_placeholder_t,
 
14668
  &_swigt__p_svn_fs_lock_target_t,
 
14669
  &_swigt__p_svn_fs_node_relation_t,
12285
14670
  &_swigt__p_svn_fs_pack_notify_action_t,
12286
14671
  &_swigt__p_svn_fs_path_change2_t,
12287
14672
  &_swigt__p_svn_fs_path_change_kind_t,
12289
14674
  &_swigt__p_svn_fs_root_t,
12290
14675
  &_swigt__p_svn_fs_t,
12291
14676
  &_swigt__p_svn_fs_txn_t,
 
14677
  &_swigt__p_svn_fs_upgrade_notify_action_t,
12292
14678
  &_swigt__p_svn_io_dirent2_t,
12293
14679
  &_swigt__p_svn_io_dirent_t,
12294
14680
  &_swigt__p_svn_io_file_del_t,
12331
14717
static swig_cast_info _swigc__p_apr_int32_t[] = {  {&_swigt__p_apr_int32_t, 0, 0, 0},{0, 0, 0, 0}};
12332
14718
static swig_cast_info _swigc__p_apr_int64_t[] = {  {&_swigt__p_apr_int64_t, 0, 0, 0},{0, 0, 0, 0}};
12333
14719
static swig_cast_info _swigc__p_apr_pool_t[] = {  {&_swigt__p_apr_pool_t, 0, 0, 0},{0, 0, 0, 0}};
 
14720
static swig_cast_info _swigc__p_apr_uint64_t[] = {  {&_swigt__p_apr_uint64_t, 0, 0, 0},{0, 0, 0, 0}};
12334
14721
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
12335
14722
static swig_cast_info _swigc__p_f_long_p_void_p_apr_pool_t__void[] = {  {&_swigt__p_f_long_p_void_p_apr_pool_t__void, 0, 0, 0},{0, 0, 0, 0}};
12336
14723
static swig_cast_info _swigc__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
12337
14724
static swig_cast_info _swigc__p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
12338
14725
static swig_cast_info _swigc__p_f_p_void__p_svn_error_t[] = {  {&_swigt__p_f_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
12339
14726
static swig_cast_info _swigc__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
14727
static swig_cast_info _swigc__p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
14728
static swig_cast_info _swigc__p_f_p_void_long_long_p_apr_pool_t__void[] = {  {&_swigt__p_f_p_void_long_long_p_apr_pool_t__void, 0, 0, 0},{0, 0, 0, 0}};
12340
14729
static swig_cast_info _swigc__p_f_p_void_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
14730
static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
12341
14731
static swig_cast_info _swigc__p_f_p_void_p_struct_svn_error_t__void[] = {  {&_swigt__p_f_p_void_p_struct_svn_error_t__void, 0, 0, 0},{0, 0, 0, 0}};
12342
14732
static swig_cast_info _swigc__p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
12343
14733
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
12349
14739
static swig_cast_info _swigc__p_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
12350
14740
static swig_cast_info _swigc__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t[] = {  {&_swigt__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
12351
14741
static swig_cast_info _swigc__p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
14742
static swig_cast_info _swigc__p_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
14743
static swig_cast_info _swigc__p_p_f_p_void_long_long_p_apr_pool_t__void[] = {  {&_swigt__p_p_f_p_void_long_long_p_apr_pool_t__void, 0, 0, 0},{0, 0, 0, 0}};
12352
14744
static swig_cast_info _swigc__p_p_f_p_void_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_p_f_p_void_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
 
14745
static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
12353
14746
static swig_cast_info _swigc__p_p_f_p_void_p_struct_svn_error_t__void[] = {  {&_swigt__p_p_f_p_void_p_struct_svn_error_t__void, 0, 0, 0},{0, 0, 0, 0}};
12354
14747
static swig_cast_info _swigc__p_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t[] = {  {&_swigt__p_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
12355
14748
static swig_cast_info _swigc__p_p_svn_checksum_t[] = {  {&_swigt__p_p_svn_checksum_t, 0, 0, 0},{0, 0, 0, 0}};
12356
14749
static swig_cast_info _swigc__p_p_svn_fs_access_t[] = {  {&_swigt__p_p_svn_fs_access_t, 0, 0, 0},{0, 0, 0, 0}};
12357
14750
static swig_cast_info _swigc__p_p_svn_fs_history_t[] = {  {&_swigt__p_p_svn_fs_history_t, 0, 0, 0},{0, 0, 0, 0}};
12358
14751
static swig_cast_info _swigc__p_p_svn_fs_id_t[] = {  {&_swigt__p_p_svn_fs_id_t, 0, 0, 0},{0, 0, 0, 0}};
 
14752
static swig_cast_info _swigc__p_p_svn_fs_info_placeholder_t[] = {  {&_swigt__p_p_svn_fs_info_placeholder_t, 0, 0, 0},{0, 0, 0, 0}};
12359
14753
static swig_cast_info _swigc__p_p_svn_fs_root_t[] = {  {&_swigt__p_p_svn_fs_root_t, 0, 0, 0},{0, 0, 0, 0}};
12360
14754
static swig_cast_info _swigc__p_p_svn_fs_t[] = {  {&_swigt__p_p_svn_fs_t, 0, 0, 0},{0, 0, 0, 0}};
12361
14755
static swig_cast_info _swigc__p_p_svn_fs_txn_t[] = {  {&_swigt__p_p_svn_fs_txn_t, 0, 0, 0},{0, 0, 0, 0}};
12363
14757
static swig_cast_info _swigc__p_p_svn_stream_t[] = {  {&_swigt__p_p_svn_stream_t, 0, 0, 0},{0, 0, 0, 0}};
12364
14758
static swig_cast_info _swigc__p_p_svn_string_t[] = {  {&_swigt__p_p_svn_string_t, 0, 0, 0},{0, 0, 0, 0}};
12365
14759
static swig_cast_info _swigc__p_p_svn_txdelta_stream_t[] = {  {&_swigt__p_p_svn_txdelta_stream_t, 0, 0, 0},{0, 0, 0, 0}};
 
14760
static swig_cast_info _swigc__p_p_svn_version_t[] = {  {&_swigt__p_p_svn_version_t, 0, 0, 0},{0, 0, 0, 0}};
12366
14761
static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
12367
14762
static swig_cast_info _swigc__p_svn_auth_baton_t[] = {  {&_swigt__p_svn_auth_baton_t, 0, 0, 0},{0, 0, 0, 0}};
12368
14763
static swig_cast_info _swigc__p_svn_auth_cred_simple_t[] = {  {&_swigt__p_svn_auth_cred_simple_t, 0, 0, 0},{0, 0, 0, 0}};
12381
14776
static swig_cast_info _swigc__p_svn_config_t[] = {  {&_swigt__p_svn_config_t, 0, 0, 0},{0, 0, 0, 0}};
12382
14777
static swig_cast_info _swigc__p_svn_delta_editor_t[] = {  {&_swigt__p_svn_delta_editor_t, 0, 0, 0},{0, 0, 0, 0}};
12383
14778
static swig_cast_info _swigc__p_svn_depth_t[] = {  {&_swigt__p_svn_depth_t, 0, 0, 0},{0, 0, 0, 0}};
 
14779
static swig_cast_info _swigc__p_svn_diff_hunk_t[] = {  {&_swigt__p_svn_diff_hunk_t, 0, 0, 0},{0, 0, 0, 0}};
12384
14780
static swig_cast_info _swigc__p_svn_dirent_t[] = {  {&_swigt__p_svn_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
12385
14781
static swig_cast_info _swigc__p_svn_errno_t[] = {  {&_swigt__p_svn_errno_t, 0, 0, 0},{0, 0, 0, 0}};
12386
14782
static swig_cast_info _swigc__p_svn_error_t[] = {  {&_swigt__p_svn_error_t, 0, 0, 0},{0, 0, 0, 0}};
12387
14783
static swig_cast_info _swigc__p_svn_fs_access_t[] = {  {&_swigt__p_svn_fs_access_t, 0, 0, 0},{0, 0, 0, 0}};
12388
14784
static swig_cast_info _swigc__p_svn_fs_dirent_t[] = {  {&_swigt__p_svn_fs_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
 
14785
static swig_cast_info _swigc__p_svn_fs_fsfs_info_t[] = {  {&_swigt__p_svn_fs_fsfs_info_t, 0, 0, 0},{0, 0, 0, 0}};
 
14786
static swig_cast_info _swigc__p_svn_fs_fsx_info_t[] = {  {&_swigt__p_svn_fs_fsx_info_t, 0, 0, 0},{0, 0, 0, 0}};
12389
14787
static swig_cast_info _swigc__p_svn_fs_history_t[] = {  {&_swigt__p_svn_fs_history_t, 0, 0, 0},{0, 0, 0, 0}};
12390
14788
static swig_cast_info _swigc__p_svn_fs_id_t[] = {  {&_swigt__p_svn_fs_id_t, 0, 0, 0},{0, 0, 0, 0}};
 
14789
static swig_cast_info _swigc__p_svn_fs_info_placeholder_t[] = {  {&_swigt__p_svn_fs_info_placeholder_t, 0, 0, 0},{0, 0, 0, 0}};
 
14790
static swig_cast_info _swigc__p_svn_fs_lock_target_t[] = {  {&_swigt__p_svn_fs_lock_target_t, 0, 0, 0},{0, 0, 0, 0}};
 
14791
static swig_cast_info _swigc__p_svn_fs_node_relation_t[] = {  {&_swigt__p_svn_fs_node_relation_t, 0, 0, 0},{0, 0, 0, 0}};
12391
14792
static swig_cast_info _swigc__p_svn_fs_pack_notify_action_t[] = {  {&_swigt__p_svn_fs_pack_notify_action_t, 0, 0, 0},{0, 0, 0, 0}};
12392
14793
static swig_cast_info _swigc__p_svn_fs_path_change2_t[] = {  {&_swigt__p_svn_fs_path_change2_t, 0, 0, 0},{0, 0, 0, 0}};
12393
14794
static swig_cast_info _swigc__p_svn_fs_path_change_kind_t[] = {  {&_swigt__p_svn_fs_path_change_kind_t, 0, 0, 0},{0, 0, 0, 0}};
12395
14796
static swig_cast_info _swigc__p_svn_fs_root_t[] = {  {&_swigt__p_svn_fs_root_t, 0, 0, 0},{0, 0, 0, 0}};
12396
14797
static swig_cast_info _swigc__p_svn_fs_t[] = {  {&_swigt__p_svn_fs_t, 0, 0, 0},{0, 0, 0, 0}};
12397
14798
static swig_cast_info _swigc__p_svn_fs_txn_t[] = {  {&_swigt__p_svn_fs_txn_t, 0, 0, 0},{0, 0, 0, 0}};
 
14799
static swig_cast_info _swigc__p_svn_fs_upgrade_notify_action_t[] = {  {&_swigt__p_svn_fs_upgrade_notify_action_t, 0, 0, 0},{0, 0, 0, 0}};
12398
14800
static swig_cast_info _swigc__p_svn_io_dirent2_t[] = {  {&_swigt__p_svn_io_dirent2_t, 0, 0, 0},{0, 0, 0, 0}};
12399
14801
static swig_cast_info _swigc__p_svn_io_dirent_t[] = {  {&_swigt__p_svn_io_dirent_t, 0, 0, 0},{0, 0, 0, 0}};
12400
14802
static swig_cast_info _swigc__p_svn_io_file_del_t[] = {  {&_swigt__p_svn_io_file_del_t, 0, 0, 0},{0, 0, 0, 0}};
12437
14839
  _swigc__p_apr_int32_t,
12438
14840
  _swigc__p_apr_int64_t,
12439
14841
  _swigc__p_apr_pool_t,
 
14842
  _swigc__p_apr_uint64_t,
12440
14843
  _swigc__p_char,
12441
14844
  _swigc__p_f_long_p_void_p_apr_pool_t__void,
12442
14845
  _swigc__p_f_p_apr_getopt_t_p_void_p_apr_pool_t__p_svn_error_t,
12443
14846
  _swigc__p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t,
12444
14847
  _swigc__p_f_p_void__p_svn_error_t,
12445
14848
  _swigc__p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t,
 
14849
  _swigc__p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t,
 
14850
  _swigc__p_f_p_void_long_long_p_apr_pool_t__void,
12446
14851
  _swigc__p_f_p_void_p_apr_pool_t__p_svn_error_t,
 
14852
  _swigc__p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
12447
14853
  _swigc__p_f_p_void_p_struct_svn_error_t__void,
12448
14854
  _swigc__p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t,
12449
14855
  _swigc__p_int,
12455
14861
  _swigc__p_p_f_p_q_const__unsigned_char_apr_size_t_p_void_p_apr_pool_t__p_svn_error_t,
12456
14862
  _swigc__p_p_f_p_svn_txdelta_window_t_p_void__p_svn_error_t,
12457
14863
  _swigc__p_p_f_p_void_apr_int64_t_svn_fs_pack_notify_action_t_p_apr_pool_t__p_svn_error_t,
 
14864
  _swigc__p_p_f_p_void_apr_uint64_t_svn_fs_upgrade_notify_action_t_p_apr_pool_t__p_svn_error_t,
 
14865
  _swigc__p_p_f_p_void_long_long_p_apr_pool_t__void,
12458
14866
  _swigc__p_p_f_p_void_p_apr_pool_t__p_svn_error_t,
 
14867
  _swigc__p_p_f_p_void_p_q_const__char_p_q_const__svn_lock_t_p_svn_error_t_p_apr_pool_t__p_svn_error_t,
12459
14868
  _swigc__p_p_f_p_void_p_struct_svn_error_t__void,
12460
14869
  _swigc__p_p_f_p_void_p_svn_lock_t_p_apr_pool_t__p_svn_error_t,
12461
14870
  _swigc__p_p_svn_checksum_t,
12462
14871
  _swigc__p_p_svn_fs_access_t,
12463
14872
  _swigc__p_p_svn_fs_history_t,
12464
14873
  _swigc__p_p_svn_fs_id_t,
 
14874
  _swigc__p_p_svn_fs_info_placeholder_t,
12465
14875
  _swigc__p_p_svn_fs_root_t,
12466
14876
  _swigc__p_p_svn_fs_t,
12467
14877
  _swigc__p_p_svn_fs_txn_t,
12469
14879
  _swigc__p_p_svn_stream_t,
12470
14880
  _swigc__p_p_svn_string_t,
12471
14881
  _swigc__p_p_svn_txdelta_stream_t,
 
14882
  _swigc__p_p_svn_version_t,
12472
14883
  _swigc__p_p_void,
12473
14884
  _swigc__p_svn_auth_baton_t,
12474
14885
  _swigc__p_svn_auth_cred_simple_t,
12487
14898
  _swigc__p_svn_config_t,
12488
14899
  _swigc__p_svn_delta_editor_t,
12489
14900
  _swigc__p_svn_depth_t,
 
14901
  _swigc__p_svn_diff_hunk_t,
12490
14902
  _swigc__p_svn_dirent_t,
12491
14903
  _swigc__p_svn_errno_t,
12492
14904
  _swigc__p_svn_error_t,
12493
14905
  _swigc__p_svn_fs_access_t,
12494
14906
  _swigc__p_svn_fs_dirent_t,
 
14907
  _swigc__p_svn_fs_fsfs_info_t,
 
14908
  _swigc__p_svn_fs_fsx_info_t,
12495
14909
  _swigc__p_svn_fs_history_t,
12496
14910
  _swigc__p_svn_fs_id_t,
 
14911
  _swigc__p_svn_fs_info_placeholder_t,
 
14912
  _swigc__p_svn_fs_lock_target_t,
 
14913
  _swigc__p_svn_fs_node_relation_t,
12497
14914
  _swigc__p_svn_fs_pack_notify_action_t,
12498
14915
  _swigc__p_svn_fs_path_change2_t,
12499
14916
  _swigc__p_svn_fs_path_change_kind_t,
12501
14918
  _swigc__p_svn_fs_root_t,
12502
14919
  _swigc__p_svn_fs_t,
12503
14920
  _swigc__p_svn_fs_txn_t,
 
14921
  _swigc__p_svn_fs_upgrade_notify_action_t,
12504
14922
  _swigc__p_svn_io_dirent2_t,
12505
14923
  _swigc__p_svn_io_dirent_t,
12506
14924
  _swigc__p_svn_io_file_del_t,
12549
14967
#endif
12550
14968
/* -----------------------------------------------------------------------------
12551
14969
 * Type initialization:
12552
 
 * This problem is tough by the requirement that no dynamic 
12553
 
 * memory is used. Also, since swig_type_info structures store pointers to 
 
14970
 * This problem is tough by the requirement that no dynamic
 
14971
 * memory is used. Also, since swig_type_info structures store pointers to
12554
14972
 * swig_cast_info structures and swig_cast_info structures store pointers back
12555
 
 * to swig_type_info structures, we need some lookup code at initialization. 
12556
 
 * The idea is that swig generates all the structures that are needed. 
12557
 
 * The runtime then collects these partially filled structures. 
12558
 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
14973
 * to swig_type_info structures, we need some lookup code at initialization.
 
14974
 * The idea is that swig generates all the structures that are needed.
 
14975
 * The runtime then collects these partially filled structures.
 
14976
 * The SWIG_InitializeModule function takes these initial arrays out of
12559
14977
 * swig_module, and does all the lookup, filling in the swig_module.types
12560
14978
 * array with the correct data and linking the correct swig_cast_info
12561
14979
 * structures together.
12562
14980
 *
12563
 
 * The generated swig_type_info structures are assigned staticly to an initial 
 
14981
 * The generated swig_type_info structures are assigned staticly to an initial
12564
14982
 * array. We just loop through that array, and handle each type individually.
12565
14983
 * First we lookup if this type has been already loaded, and if so, use the
12566
14984
 * loaded structure instead of the generated one. Then we have to fill in the
12570
14988
 * a column is one of the swig_cast_info structures for that type.
12571
14989
 * The cast_initial array is actually an array of arrays, because each row has
12572
14990
 * a variable number of columns. So to actually build the cast linked list,
12573
 
 * we find the array of casts associated with the type, and loop through it 
 
14991
 * we find the array of casts associated with the type, and loop through it
12574
14992
 * adding the casts to the list. The one last trick we need to do is making
12575
14993
 * sure the type pointer in the swig_cast_info struct is correct.
12576
14994
 *
12577
 
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
14995
 * First off, we lookup the cast->type name to see if it is already loaded.
12578
14996
 * There are three cases to handle:
12579
14997
 *  1) If the cast->type has already been loaded AND the type we are adding
12580
14998
 *     casting info to has not been loaded (it is in this module), THEN we
12581
14999
 *     replace the cast->type pointer with the type pointer that has already
12582
15000
 *     been loaded.
12583
 
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
15001
 *  2) If BOTH types (the one we are adding casting info to, and the
12584
15002
 *     cast->type) are loaded, THEN the cast info has already been loaded by
12585
15003
 *     the previous module so we just ignore it.
12586
15004
 *  3) Finally, if cast->type has not already been loaded, then we add that
12643
15061
    module_head->next = &swig_module;
12644
15062
  }
12645
15063
  
12646
 
  /* When multiple interpeters are used, a module could have already been initialized in
 
15064
  /* When multiple interpreters are used, a module could have already been initialized in
12647
15065
       a different interpreter, but not yet have a pointer in this interpreter.
12648
15066
       In this case, we do not want to continue adding types... everything should be
12649
15067
       set up already */
13220
15638
  
13221
15639
  SWIG_InstallConstants(d,swig_const_table);
13222
15640
  
 
15641
  SWIG_Python_SetConstant(d, "SVN_FS_TYPE_BDB",SWIG_FromCharPtr("bdb"));
 
15642
  SWIG_Python_SetConstant(d, "SVN_FS_TYPE_FSFS",SWIG_FromCharPtr("fsfs"));
 
15643
  SWIG_Python_SetConstant(d, "SVN_FS_TYPE_FSX",SWIG_FromCharPtr("fsx"));
13223
15644
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_BDB_TXN_NOSYNC",SWIG_FromCharPtr("bdb-txn-nosync"));
13224
15645
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_BDB_LOG_AUTOREMOVE",SWIG_FromCharPtr("bdb-log-autoremove"));
13225
15646
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_FSFS_CACHE_DELTAS",SWIG_FromCharPtr("fsfs-cache-deltas"));
13226
15647
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_FSFS_CACHE_FULLTEXTS",SWIG_FromCharPtr("fsfs-cache-fulltexts"));
13227
15648
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_FSFS_CACHE_REVPROPS",SWIG_FromCharPtr("fsfs-cache-revprops"));
13228
15649
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_FSFS_CACHE_NS",SWIG_FromCharPtr("fsfs-cache-namespace"));
 
15650
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_FSFS_BLOCK_READ",SWIG_FromCharPtr("fsfs-block-read"));
 
15651
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_FSFS_SHARD_SIZE",SWIG_FromCharPtr("fsfs-shard-size"));
 
15652
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_FSFS_LOG_ADDRESSING",SWIG_FromCharPtr("fsfs-log-addressing"));
13229
15653
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_FS_TYPE",SWIG_FromCharPtr("fs-type"));
13230
 
  SWIG_Python_SetConstant(d, "SVN_FS_TYPE_BDB",SWIG_FromCharPtr("bdb"));
13231
 
  SWIG_Python_SetConstant(d, "SVN_FS_TYPE_FSFS",SWIG_FromCharPtr("fsfs"));
13232
15654
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_PRE_1_4_COMPATIBLE",SWIG_FromCharPtr("pre-1.4-compatible"));
13233
15655
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_PRE_1_5_COMPATIBLE",SWIG_FromCharPtr("pre-1.5-compatible"));
13234
15656
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_PRE_1_6_COMPATIBLE",SWIG_FromCharPtr("pre-1.6-compatible"));
13235
15657
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_PRE_1_8_COMPATIBLE",SWIG_FromCharPtr("pre-1.8-compatible"));
 
15658
  SWIG_Python_SetConstant(d, "SVN_FS_CONFIG_COMPATIBLE_VERSION",SWIG_FromCharPtr("compatible-version"));
 
15659
  SWIG_Python_SetConstant(d, "svn_fs_upgrade_pack_revprops",SWIG_From_long((long)(svn_fs_upgrade_pack_revprops)));
 
15660
  SWIG_Python_SetConstant(d, "svn_fs_upgrade_cleanup_revprops",SWIG_From_long((long)(svn_fs_upgrade_cleanup_revprops)));
 
15661
  SWIG_Python_SetConstant(d, "svn_fs_upgrade_format_bumped",SWIG_From_long((long)(svn_fs_upgrade_format_bumped)));
 
15662
  SWIG_Python_SetConstant(d, "svn_fs_node_unrelated",SWIG_From_long((long)(svn_fs_node_unrelated)));
 
15663
  SWIG_Python_SetConstant(d, "svn_fs_node_unchanged",SWIG_From_long((long)(svn_fs_node_unchanged)));
 
15664
  SWIG_Python_SetConstant(d, "svn_fs_node_common_ancestor",SWIG_From_long((long)(svn_fs_node_common_ancestor)));
13236
15665
  SWIG_Python_SetConstant(d, "SVN_FS_TXN_CHECK_OOD",SWIG_From_long((long)(0x00001)));
13237
15666
  SWIG_Python_SetConstant(d, "SVN_FS_TXN_CHECK_LOCKS",SWIG_From_long((long)(0x00002)));
 
15667
  SWIG_Python_SetConstant(d, "SVN_FS_TXN_CLIENT_DATE",SWIG_From_long((long)(0x00004)));
13238
15668
  SWIG_Python_SetConstant(d, "svn_fs_path_change_modify",SWIG_From_long((long)(svn_fs_path_change_modify)));
13239
15669
  SWIG_Python_SetConstant(d, "svn_fs_path_change_add",SWIG_From_long((long)(svn_fs_path_change_add)));
13240
15670
  SWIG_Python_SetConstant(d, "svn_fs_path_change_delete",SWIG_From_long((long)(svn_fs_path_change_delete)));