credentials results from the CPAN

credentials

Alien-SVN

view release on metacpan or search on metacpan

src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN

    }
  } else
#endif
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
	if (val) *val = (unsigned long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERNINLINE unsigned long
SWIG_As_unsigned_SS_long (PyObject* obj)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (!SWIG_IsOK(res)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(unsigned long));
    SWIG_Error(res, "");
  }
  return v;
}


SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyLong_FromLong((long)(value)); 
}


static svn_error_t * svn_auth_provider_invoke_first_credentials(
  svn_auth_provider_t * _obj, void **credentials, void **iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
  return (_obj->first_credentials)(credentials, iter_baton, provider_baton, parameters, realmstring, pool);
}

static svn_error_t * svn_auth_provider_invoke_next_credentials(
  svn_auth_provider_t * _obj, void **credentials, void *iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
  return (_obj->next_credentials)(credentials, iter_baton, provider_baton, parameters, realmstring, pool);
}

static svn_error_t * svn_auth_provider_invoke_save_credentials(
  svn_auth_provider_t * _obj, svn_boolean_t *saved, void *credentials, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
  return (_obj->save_credentials)(saved, credentials, provider_baton, parameters, realmstring, pool);
}

static void svn_auth_invoke_simple_provider_func(
  svn_auth_simple_provider_func_t _obj, svn_auth_provider_object_t **provider, apr_pool_t *pool) {
  _obj(provider, pool);
}

static void svn_auth_invoke_ssl_client_cert_pw_provider_func(
  svn_auth_ssl_client_cert_pw_provider_func_t _obj, svn_auth_provider_object_t **provider, apr_pool_t *pool) {
  _obj(provider, pool);
}

static svn_error_t * svn_auth_invoke_simple_prompt_func(
  svn_auth_simple_prompt_func_t _obj, svn_auth_cred_simple_t **cred, void *baton, const char *realm, const char *username, svn_boolean_t may_save, apr_pool_t *pool) {
  return _obj(cred, baton, realm, username, may_save, pool);
}

static svn_error_t * svn_auth_invoke_username_prompt_func(
  svn_auth_username_prompt_func_t _obj, svn_auth_cred_username_t **cred, void *baton, const char *realm, svn_boolean_t may_save, apr_pool_t *pool) {
  return _obj(cred, baton, realm, may_save, pool);
}

static svn_error_t * svn_auth_invoke_ssl_server_trust_prompt_func(
  svn_auth_ssl_server_trust_prompt_func_t _obj, svn_auth_cred_ssl_server_trust_t **cred, void *baton, const char *realm, apr_uint32_t failures, const svn_auth_ssl_server_cert_info_t *cert_info, svn_boolean_t may_save, apr_pool_t *pool) {
  return _obj(cred, baton, realm, failures, cert_info, may_save, pool);
}

static svn_error_t * svn_auth_invoke_ssl_client_cert_prompt_func(
  svn_auth_ssl_client_cert_prompt_func_t _obj, svn_auth_cred_ssl_client_cert_t **cred, void *baton, const char *realm, svn_boolean_t may_save, apr_pool_t *pool) {
  return _obj(cred, baton, realm, may_save, pool);
}

static svn_error_t * svn_auth_invoke_ssl_client_cert_pw_prompt_func(
  svn_auth_ssl_client_cert_pw_prompt_func_t _obj, svn_auth_cred_ssl_client_cert_pw_t **cred, void *baton, const char *realm, svn_boolean_t may_save, apr_pool_t *pool) {
  return _obj(cred, baton, realm, may_save, pool);
}

static svn_error_t * svn_auth_invoke_plaintext_prompt_func(
  svn_auth_plaintext_prompt_func_t _obj, svn_boolean_t *may_save_plaintext, const char *realmstring, void *baton, apr_pool_t *pool) {
  return _obj(may_save_plaintext, realmstring, baton, pool);
}

static svn_error_t * svn_auth_invoke_plaintext_passphrase_prompt_func(
  svn_auth_plaintext_passphrase_prompt_func_t _obj, svn_boolean_t *may_save_plaintext, const char *realmstring, void *baton, apr_pool_t *pool) {
  return _obj(may_save_plaintext, realmstring, baton, pool);
}



#include "svn_config.h"


static svn_boolean_t svn_config_invoke_section_enumerator(
  svn_config_section_enumerator_t _obj, const char *name, void *baton) {
  return _obj(name, baton);
}

static svn_boolean_t svn_config_invoke_section_enumerator2(
  svn_config_section_enumerator2_t _obj, const char *name, void *baton, apr_pool_t *pool) {
  return _obj(name, baton, pool);

src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN

    Py_XDECREF(_global_py_pool);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(_global_py_pool);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_provider_t_cred_kind_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  char *arg2 = (char *) 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"Os:svn_auth_provider_t_cred_kind_set",&obj0,&arg2)) SWIG_fail;
  {
    arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  {
    apr_size_t len = strlen(arg2) + 1;
    char *copied;
    if (arg1->cred_kind) free((char *)arg1->cred_kind);
    copied = malloc(len);
    memcpy(copied, arg2, len);
    arg1->cred_kind = copied;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_provider_t_cred_kind_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:svn_auth_provider_t_cred_kind_get",&obj0)) SWIG_fail;
  {
    arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  result = (char *) ((arg1)->cred_kind);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_provider_t_first_credentials_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  svn_error_t *(*arg2)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_auth_provider_t_first_credentials_set",&obj0,&obj1)) SWIG_fail;
  {
    arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_auth_provider_t_first_credentials_set" "', argument " "2"" of type '" "svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)""'"); 
    }
  }
  if (arg1) (arg1)->first_credentials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_provider_t_first_credentials_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  PyObject * obj0 = 0 ;
  svn_error_t *(*result)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:svn_auth_provider_t_first_credentials_get",&obj0)) SWIG_fail;
  {
    arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  result = (svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->first_credentials);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_provider_t_next_credentials_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  svn_error_t *(*arg2)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_auth_provider_t_next_credentials_set",&obj0,&obj1)) SWIG_fail;
  {
    arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_auth_provider_t_next_credentials_set" "', argument " "2"" of type '" "svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)""'"); 
    }
  }
  if (arg1) (arg1)->next_credentials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_provider_t_next_credentials_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  PyObject * obj0 = 0 ;
  svn_error_t *(*result)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:svn_auth_provider_t_next_credentials_get",&obj0)) SWIG_fail;
  {
    arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  result = (svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->next_credentials);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_provider_t_save_credentials_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  svn_error_t *(*arg2)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:svn_auth_provider_t_save_credentials_set",&obj0,&obj1)) SWIG_fail;
  {
    arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_svn_boolean_t_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_auth_provider_t_save_credentials_set" "', argument " "2"" of type '" "svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)""'"); 
    }
  }
  if (arg1) (arg1)->save_credentials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_provider_t_save_credentials_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  PyObject * obj0 = 0 ;
  svn_error_t *(*result)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:svn_auth_provider_t_save_credentials_get",&obj0)) SWIG_fail;
  {
    arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  result = (svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->save_credentials);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_svn_boolean_t_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_svn_auth_provider_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct svn_auth_provider_t *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_svn_auth_provider_t")) SWIG_fail;
  {
    svn_swig_py_release_py_lock();
    
    result = (struct svn_auth_provider_t *)calloc(1, sizeof(struct svn_auth_provider_t));
    
    svn_swig_py_acquire_py_lock();
    
  }
  resultobj = svn_swig_NewPointerObj((void*)(result), SWIGTYPE_p_svn_auth_provider_t,
    _global_py_pool, args);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_svn_auth_provider_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_svn_auth_provider_t",&obj0)) SWIG_fail;
  {
    arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  {
    svn_swig_py_release_py_lock();
    
    free((char *) arg1);
    
    svn_swig_py_acquire_py_lock();
    
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *svn_auth_provider_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_svn_auth_provider_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();

src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN

  char *arg2 = (char *) 0 ;
  void *arg3 = (void *) 0 ;
  apr_pool_t *_global_pool = NULL ;
  PyObject *_global_py_pool = NULL ;
  PyObject * obj0 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OsO:svn_auth_set_parameter",&obj0,&arg2,&obj2)) SWIG_fail;
  {
    arg1 = (svn_auth_baton_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_baton_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  {
    if (_global_pool == NULL)
    {
      if (svn_swig_py_get_parent_pool(args, SWIGTYPE_p_apr_pool_t,
          &_global_py_pool, &_global_pool))
      SWIG_fail;
    }
    
    if (PyString_Check(obj2)) {
      char *value = PyString_AS_STRING(obj2);
      arg3 = apr_pstrdup(_global_pool, value);
    }
    else if (PyLong_Check(obj2)) {
      arg3 = apr_palloc(_global_pool, sizeof(apr_uint32_t));
      *((apr_uint32_t *)arg3) = PyLong_AsLong(obj2);
    }
    else if (PyInt_Check(obj2)) {
      arg3 = apr_palloc(_global_pool, sizeof(apr_uint32_t));
      *((apr_uint32_t *)arg3) = PyInt_AsLong(obj2);
    }
    else if (obj2 == Py_None) {
      arg3 = NULL;
    }
    else if (svn_swig_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_svn_auth_ssl_server_cert_info_t) == 0) {
      
    }
    else {
      PyErr_SetString(PyExc_TypeError, "not a known type");
      SWIG_fail;
    }
  }
  {
    svn_swig_py_release_py_lock();
    
    svn_auth_set_parameter(arg1,(char const *)arg2,(void const *)arg3);
    
    svn_swig_py_acquire_py_lock();
    
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_first_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  void **arg1 = (void **) 0 ;
  svn_auth_iterstate_t **arg2 = (svn_auth_iterstate_t **) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  svn_auth_baton_t *arg5 = (svn_auth_baton_t *) 0 ;
  apr_pool_t *arg6 = (apr_pool_t *) 0 ;
  apr_pool_t *_global_pool = NULL ;
  PyObject *_global_py_pool = NULL ;
  void *temp1 ;
  svn_auth_iterstate_t *temp2 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  svn_error_t *result = 0 ;
  
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
      &_global_py_pool, &_global_pool))
  SWIG_fail;
  arg6 = _global_pool;
  arg1 = &temp1;
  arg2 = &temp2;
  if (!PyArg_ParseTuple(args,(char *)"ssO|O:svn_auth_first_credentials",&arg3,&arg4,&obj2,&obj3)) SWIG_fail;
  {
    arg5 = (svn_auth_baton_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_auth_baton_t, svn_argnum_obj2);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  if (obj3) {
    /* Verify that the user supplied a valid pool */
    if (obj3 != Py_None && obj3 != _global_py_pool) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
      SWIG_arg_fail(svn_argnum_obj3);
      SWIG_fail;
    }
  }
  {
    svn_swig_py_release_py_lock();
    
    result = (svn_error_t *)svn_auth_first_credentials(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6);
    
    svn_swig_py_acquire_py_lock();
    
  }
  {
    if (result != NULL) {
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
      svn_swig_py_svn_exception(result);
      else
      svn_error_clear(result);
      SWIG_fail;
    }
    Py_INCREF(Py_None);
    resultobj = Py_None;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_void,
        _global_py_pool, args))
    
    ;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_svn_auth_iterstate_t,
        _global_py_pool, args))
    
    ;
  }
  {
    Py_XDECREF(_global_py_pool);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(_global_py_pool);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_next_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  void **arg1 = (void **) 0 ;
  svn_auth_iterstate_t *arg2 = (svn_auth_iterstate_t *) 0 ;
  apr_pool_t *arg3 = (apr_pool_t *) 0 ;
  apr_pool_t *_global_pool = NULL ;
  PyObject *_global_py_pool = NULL ;
  void *temp1 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  svn_error_t *result = 0 ;
  
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
      &_global_py_pool, &_global_pool))
  SWIG_fail;
  arg3 = _global_pool;
  arg1 = &temp1;
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_auth_next_credentials",&obj0,&obj1)) SWIG_fail;
  {
    arg2 = (svn_auth_iterstate_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_iterstate_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  if (obj1) {
    /* Verify that the user supplied a valid pool */
    if (obj1 != Py_None && obj1 != _global_py_pool) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
      SWIG_arg_fail(svn_argnum_obj1);
      SWIG_fail;
    }
  }
  {
    svn_swig_py_release_py_lock();
    
    result = (svn_error_t *)svn_auth_next_credentials(arg1,arg2,arg3);
    
    svn_swig_py_acquire_py_lock();
    
  }
  {
    if (result != NULL) {
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
      svn_swig_py_svn_exception(result);
      else
      svn_error_clear(result);
      SWIG_fail;
    }
    Py_INCREF(Py_None);
    resultobj = Py_None;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_void,
        _global_py_pool, args))
    
    ;
  }
  {
    Py_XDECREF(_global_py_pool);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(_global_py_pool);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_save_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  svn_auth_iterstate_t *arg1 = (svn_auth_iterstate_t *) 0 ;
  apr_pool_t *arg2 = (apr_pool_t *) 0 ;
  apr_pool_t *_global_pool = NULL ;
  PyObject *_global_py_pool = NULL ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  svn_error_t *result = 0 ;
  
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
      &_global_py_pool, &_global_pool))
  SWIG_fail;
  arg2 = _global_pool;
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_auth_save_credentials",&obj0,&obj1)) SWIG_fail;
  {
    arg1 = (svn_auth_iterstate_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_iterstate_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  if (obj1) {
    /* Verify that the user supplied a valid pool */
    if (obj1 != Py_None && obj1 != _global_py_pool) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
      SWIG_arg_fail(svn_argnum_obj1);
      SWIG_fail;
    }
  }
  {
    svn_swig_py_release_py_lock();
    
    result = (svn_error_t *)svn_auth_save_credentials(arg1,arg2);
    
    svn_swig_py_acquire_py_lock();
    
  }
  {
    if (result != NULL) {
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
      svn_swig_py_svn_exception(result);
      else
      svn_error_clear(result);
      SWIG_fail;
    }
    Py_INCREF(Py_None);
    resultobj = Py_None;
  }
  {
    Py_XDECREF(_global_py_pool);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(_global_py_pool);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_forget_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  svn_auth_baton_t *arg1 = (svn_auth_baton_t *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  apr_pool_t *arg4 = (apr_pool_t *) 0 ;
  apr_pool_t *_global_pool = NULL ;
  PyObject *_global_py_pool = NULL ;
  PyObject * obj0 = 0 ;
  PyObject * obj3 = 0 ;
  svn_error_t *result = 0 ;
  
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
      &_global_py_pool, &_global_pool))
  SWIG_fail;
  arg4 = _global_pool;
  if (!PyArg_ParseTuple(args,(char *)"Oss|O:svn_auth_forget_credentials",&obj0,&arg2,&arg3,&obj3)) SWIG_fail;
  {
    arg1 = (svn_auth_baton_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_baton_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  if (obj3) {
    /* Verify that the user supplied a valid pool */
    if (obj3 != Py_None && obj3 != _global_py_pool) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
      SWIG_arg_fail(svn_argnum_obj3);
      SWIG_fail;
    }
  }
  {
    svn_swig_py_release_py_lock();
    
    result = (svn_error_t *)svn_auth_forget_credentials(arg1,(char const *)arg2,(char const *)arg3,arg4);
    
    svn_swig_py_acquire_py_lock();
    
  }
  {
    if (result != NULL) {
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
      svn_swig_py_svn_exception(result);
      else
      svn_error_clear(result);
      SWIG_fail;
    }
    Py_INCREF(Py_None);
    resultobj = Py_None;
  }
  {
    Py_XDECREF(_global_py_pool);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(_global_py_pool);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_get_simple_prompt_provider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  svn_auth_provider_object_t **arg1 = (svn_auth_provider_object_t **) 0 ;
  svn_auth_simple_prompt_func_t arg2 = (svn_auth_simple_prompt_func_t) 0 ;
  void *arg3 = (void *) 0 ;
  int arg4 ;
  apr_pool_t *arg5 = (apr_pool_t *) 0 ;
  apr_pool_t *_global_pool = NULL ;
  PyObject *_global_py_pool = NULL ;
  svn_auth_provider_object_t *temp1 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
      &_global_py_pool, &_global_pool))
  SWIG_fail;
  arg5 = _global_pool;
  arg1 = &temp1;
  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_auth_get_simple_prompt_provider",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    arg2 = svn_swig_py_auth_simple_prompt_func;
    arg3 = obj0;
  }
  {
    arg4 = (int)SWIG_As_long (obj1);
    if (SWIG_arg_fail(svn_argnum_obj1)) {
      SWIG_fail;
    }
  }
  if (obj2) {
    /* Verify that the user supplied a valid pool */
    if (obj2 != Py_None && obj2 != _global_py_pool) {

src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN

  if (!PyArg_ParseTuple(args,(char *)"OO|O:svn_auth_get_ssl_client_cert_pw_prompt_provider",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    arg2 = svn_swig_py_auth_ssl_client_cert_pw_prompt_func;
    arg3 = obj0;
  }
  {
    arg4 = (int)SWIG_As_long (obj1);
    if (SWIG_arg_fail(svn_argnum_obj1)) {
      SWIG_fail;
    }
  }
  if (obj2) {
    /* Verify that the user supplied a valid pool */
    if (obj2 != Py_None && obj2 != _global_py_pool) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj2);
      SWIG_arg_fail(svn_argnum_obj2);
      SWIG_fail;
    }
  }
  {
    svn_swig_py_release_py_lock();
    
    svn_auth_get_ssl_client_cert_pw_prompt_provider(arg1,arg2,arg3,arg4,arg5);
    
    svn_swig_py_acquire_py_lock();
    
  }
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg1, SWIGTYPE_p_svn_auth_provider_object_t,
        _global_py_pool, args))
    
    ;
  }
  {
    Py_XDECREF(_global_py_pool);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(_global_py_pool);
  }
  return NULL;
}


SWIGINTERN PyObject *svn_auth_baton_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_svn_auth_baton_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *svn_auth_iterstate_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_svn_auth_iterstate_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_svn_auth_provider_invoke_first_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
  void **arg2 = (void **) 0 ;
  void **arg3 = (void **) 0 ;
  void *arg4 = (void *) 0 ;
  apr_hash_t *arg5 = (apr_hash_t *) 0 ;
  char *arg6 = (char *) 0 ;
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
  apr_pool_t *_global_pool = NULL ;
  PyObject *_global_py_pool = NULL ;
  void *temp2 ;
  void *temp3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj4 = 0 ;
  svn_error_t *result = 0 ;
  
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
      &_global_py_pool, &_global_pool))
  SWIG_fail;
  arg7 = _global_pool;
  arg2 = &temp2;
  arg3 = &temp3;
  if (!PyArg_ParseTuple(args,(char *)"OOOs|O:svn_auth_provider_invoke_first_credentials",&obj0,&obj1,&obj2,&arg6,&obj4)) SWIG_fail;
  {
    arg1 = (svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  {
    if (obj1 == Py_None) {
      arg4 = NULL;
    } else if (SWIG_ConvertPtr(obj1, (void **) &arg4, 0, 0) == -1) {
      arg4 = (void *) obj1;
      PyErr_Clear();
    }
  }
  {
    arg5 = (apr_hash_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_apr_hash_t, svn_argnum_obj2);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  if (obj4) {
    /* Verify that the user supplied a valid pool */
    if (obj4 != Py_None && obj4 != _global_py_pool) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
      SWIG_arg_fail(svn_argnum_obj4);
      SWIG_fail;
    }
  }
  {
    svn_swig_py_release_py_lock();
    
    result = (svn_error_t *)svn_auth_provider_invoke_first_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
    
    svn_swig_py_acquire_py_lock();
    
  }
  {
    if (result != NULL) {
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
      svn_swig_py_svn_exception(result);
      else
      svn_error_clear(result);
      SWIG_fail;
    }
    Py_INCREF(Py_None);
    resultobj = Py_None;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
        _global_py_pool, args))
    
    ;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg3, SWIGTYPE_p_void,
        _global_py_pool, args))
    
    ;
  }
  {
    Py_XDECREF(_global_py_pool);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(_global_py_pool);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_provider_invoke_next_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
  void **arg2 = (void **) 0 ;
  void *arg3 = (void *) 0 ;
  void *arg4 = (void *) 0 ;
  apr_hash_t *arg5 = (apr_hash_t *) 0 ;
  char *arg6 = (char *) 0 ;
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
  apr_pool_t *_global_pool = NULL ;
  PyObject *_global_py_pool = NULL ;
  void *temp2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj5 = 0 ;
  svn_error_t *result = 0 ;
  
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
      &_global_py_pool, &_global_pool))
  SWIG_fail;
  arg7 = _global_pool;
  arg2 = &temp2;
  if (!PyArg_ParseTuple(args,(char *)"OOOOs|O:svn_auth_provider_invoke_next_credentials",&obj0,&obj1,&obj2,&obj3,&arg6,&obj5)) SWIG_fail;
  {
    arg1 = (svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  {
    if (obj1 == Py_None) {
      arg3 = NULL;
    } else if (SWIG_ConvertPtr(obj1, (void **) &arg3, 0, 0) == -1) {
      arg3 = (void *) obj1;
      PyErr_Clear();
    }
  }
  {
    if (obj2 == Py_None) {
      arg4 = NULL;
    } else if (SWIG_ConvertPtr(obj2, (void **) &arg4, 0, 0) == -1) {
      arg4 = (void *) obj2;
      PyErr_Clear();
    }
  }
  {
    arg5 = (apr_hash_t *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_apr_hash_t, svn_argnum_obj3);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  if (obj5) {
    /* Verify that the user supplied a valid pool */
    if (obj5 != Py_None && obj5 != _global_py_pool) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
      SWIG_arg_fail(svn_argnum_obj5);
      SWIG_fail;
    }
  }
  {
    svn_swig_py_release_py_lock();
    
    result = (svn_error_t *)svn_auth_provider_invoke_next_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
    
    svn_swig_py_acquire_py_lock();
    
  }
  {
    if (result != NULL) {
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
      svn_swig_py_svn_exception(result);
      else
      svn_error_clear(result);
      SWIG_fail;
    }
    Py_INCREF(Py_None);
    resultobj = Py_None;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, svn_swig_NewPointerObj(*arg2, SWIGTYPE_p_void,
        _global_py_pool, args))
    
    ;
  }
  {
    Py_XDECREF(_global_py_pool);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(_global_py_pool);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_provider_invoke_save_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
  svn_boolean_t *arg2 = (svn_boolean_t *) 0 ;
  void *arg3 = (void *) 0 ;
  void *arg4 = (void *) 0 ;
  apr_hash_t *arg5 = (apr_hash_t *) 0 ;
  char *arg6 = (char *) 0 ;
  apr_pool_t *arg7 = (apr_pool_t *) 0 ;
  apr_pool_t *_global_pool = NULL ;
  PyObject *_global_py_pool = NULL ;
  svn_boolean_t temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj5 = 0 ;
  svn_error_t *result = 0 ;
  
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
      &_global_py_pool, &_global_pool))
  SWIG_fail;
  arg7 = _global_pool;
  arg2 = &temp2;
  if (!PyArg_ParseTuple(args,(char *)"OOOOs|O:svn_auth_provider_invoke_save_credentials",&obj0,&obj1,&obj2,&obj3,&arg6,&obj5)) SWIG_fail;
  {
    arg1 = (svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  {
    arg3 = (void *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_void, svn_argnum_obj1);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  {
    if (obj2 == Py_None) {
      arg4 = NULL;
    } else if (SWIG_ConvertPtr(obj2, (void **) &arg4, 0, 0) == -1) {
      arg4 = (void *) obj2;
      PyErr_Clear();
    }
  }
  {
    arg5 = (apr_hash_t *)svn_swig_MustGetPtr(obj3, SWIGTYPE_p_apr_hash_t, svn_argnum_obj3);
    if (PyErr_Occurred()) {
      SWIG_fail;
    }
  }
  if (obj5) {
    /* Verify that the user supplied a valid pool */
    if (obj5 != Py_None && obj5 != _global_py_pool) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
      SWIG_arg_fail(svn_argnum_obj5);
      SWIG_fail;
    }
  }
  {
    svn_swig_py_release_py_lock();
    
    result = (svn_error_t *)svn_auth_provider_invoke_save_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
    
    svn_swig_py_acquire_py_lock();
    
  }
  {
    if (result != NULL) {
      if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
      svn_swig_py_svn_exception(result);
      else
      svn_error_clear(result);
      SWIG_fail;
    }
    Py_INCREF(Py_None);
    resultobj = Py_None;
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
  }
  {
    Py_XDECREF(_global_py_pool);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(_global_py_pool);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_svn_auth_invoke_simple_provider_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  svn_auth_simple_provider_func_t arg1 = (svn_auth_simple_provider_func_t) 0 ;
  svn_auth_provider_object_t **arg2 = (svn_auth_provider_object_t **) 0 ;
  apr_pool_t *arg3 = (apr_pool_t *) 0 ;
  apr_pool_t *_global_pool = NULL ;
  PyObject *_global_py_pool = NULL ;
  svn_auth_provider_object_t *temp2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
      &_global_py_pool, &_global_pool))
  SWIG_fail;
  arg3 = _global_pool;
  arg2 = &temp2;
  if (!PyArg_ParseTuple(args,(char *)"O|O:svn_auth_invoke_simple_provider_func",&obj0,&obj1)) SWIG_fail;
  {
    svn_auth_simple_provider_func_t * tmp =
    svn_swig_MustGetPtr(obj0, SWIGTYPE_p_p_f_p_p_struct_svn_auth_provider_object_t_p_apr_pool_t__void, svn_argnum_obj0);
    if (tmp == NULL || PyErr_Occurred()) {
      SWIG_fail;
    }
    arg1 = *tmp;
  }
  if (obj1) {
    /* Verify that the user supplied a valid pool */

src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN

	 { (char *)"svn_opt_revision_t_value_set", _wrap_svn_opt_revision_t_value_set, METH_VARARGS, (char *)"svn_opt_revision_t_value_set(svn_opt_revision_t self, svn_opt_revision_value_t value)"},
	 { (char *)"svn_opt_revision_t_value_get", _wrap_svn_opt_revision_t_value_get, METH_VARARGS, (char *)"svn_opt_revision_t_value_get(svn_opt_revision_t self) -> svn_opt_revision_value_t"},
	 { (char *)"new_svn_opt_revision_t", _wrap_new_svn_opt_revision_t, METH_VARARGS, (char *)"new_svn_opt_revision_t() -> svn_opt_revision_t"},
	 { (char *)"delete_svn_opt_revision_t", _wrap_delete_svn_opt_revision_t, METH_VARARGS, (char *)"delete_svn_opt_revision_t(svn_opt_revision_t self)"},
	 { (char *)"svn_opt_revision_t_swigregister", svn_opt_revision_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_opt_revision_range_t_start_set", _wrap_svn_opt_revision_range_t_start_set, METH_VARARGS, (char *)"svn_opt_revision_range_t_start_set(svn_opt_revision_range_t self, svn_opt_revision_t start)"},
	 { (char *)"svn_opt_revision_range_t_start_get", _wrap_svn_opt_revision_range_t_start_get, METH_VARARGS, (char *)"svn_opt_revision_range_t_start_get(svn_opt_revision_range_t self) -> svn_opt_revision_t"},
	 { (char *)"svn_opt_revision_range_t_end_set", _wrap_svn_opt_revision_range_t_end_set, METH_VARARGS, (char *)"svn_opt_revision_range_t_end_set(svn_opt_revision_range_t self, svn_opt_revision_t end)"},
	 { (char *)"svn_opt_revision_range_t_end_get", _wrap_svn_opt_revision_range_t_end_get, METH_VARARGS, (char *)"svn_opt_revision_range_t_end_get(svn_opt_revision_range_t self) -> svn_opt_revision_t"},
	 { (char *)"new_svn_opt_revision_range_t", _wrap_new_svn_opt_revision_range_t, METH_VARARGS, (char *)"new_svn_opt_revision_range_t() -> svn_opt_revision_range_t"},
	 { (char *)"delete_svn_opt_revision_range_t", _wrap_delete_svn_opt_revision_range_t, METH_VARARGS, (char *)"delete_svn_opt_revision_range_t(svn_opt_revision_range_t self)"},
	 { (char *)"svn_opt_revision_range_t_swigregister", svn_opt_revision_range_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_opt_parse_revision", _wrap_svn_opt_parse_revision, METH_VARARGS, (char *)"\n"
		"svn_opt_parse_revision(svn_opt_revision_t start_revision, svn_opt_revision_t end_revision, char const * arg, \n"
		"    apr_pool_t pool) -> int\n"
		""},
	 { (char *)"svn_opt_parse_revision_to_range", _wrap_svn_opt_parse_revision_to_range, METH_VARARGS, (char *)"svn_opt_parse_revision_to_range(apr_array_header_t opt_ranges, char const * arg, apr_pool_t pool) -> int"},
	 { (char *)"svn_opt_resolve_revisions", _wrap_svn_opt_resolve_revisions, METH_VARARGS, (char *)"\n"
		"svn_opt_resolve_revisions(svn_opt_revision_t peg_rev, svn_opt_revision_t op_rev, svn_boolean_t is_url, svn_boolean_t notice_local_mods, \n"
		"    apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_opt_args_to_target_array3", _wrap_svn_opt_args_to_target_array3, METH_VARARGS, (char *)"svn_opt_args_to_target_array3(apr_getopt_t * os, apr_array_header_t known_targets, apr_pool_t pool) -> svn_error_t"},
	 { (char *)"svn_opt_args_to_target_array2", _wrap_svn_opt_args_to_target_array2, METH_VARARGS, (char *)"svn_opt_args_to_target_array2(apr_getopt_t * os, apr_array_header_t known_targets, apr_pool_t pool) -> svn_error_t"},
	 { (char *)"svn_opt_parse_revprop", _wrap_svn_opt_parse_revprop, METH_VARARGS, (char *)"svn_opt_parse_revprop(char const * revprop_spec, apr_pool_t pool) -> svn_error_t"},
	 { (char *)"svn_opt_push_implicit_dot_target", _wrap_svn_opt_push_implicit_dot_target, METH_VARARGS, (char *)"svn_opt_push_implicit_dot_target(apr_array_header_t targets, apr_pool_t pool)"},
	 { (char *)"svn_opt_parse_num_args", _wrap_svn_opt_parse_num_args, METH_VARARGS, (char *)"svn_opt_parse_num_args(apr_getopt_t * os, int num_args, apr_pool_t pool) -> svn_error_t"},
	 { (char *)"svn_opt_parse_all_args", _wrap_svn_opt_parse_all_args, METH_VARARGS, (char *)"svn_opt_parse_all_args(apr_getopt_t * os, apr_pool_t pool) -> svn_error_t"},
	 { (char *)"svn_opt_parse_path", _wrap_svn_opt_parse_path, METH_VARARGS, (char *)"svn_opt_parse_path(svn_opt_revision_t rev, char const * path, apr_pool_t pool) -> svn_error_t"},
	 { (char *)"svn_opt_print_help4", _wrap_svn_opt_print_help4, METH_VARARGS, (char *)"\n"
		"svn_opt_print_help4(apr_getopt_t * os, char const * pgm_name, svn_boolean_t print_version, svn_boolean_t quiet, \n"
		"    svn_boolean_t verbose, char const * version_footer, char const * header, \n"
		"    svn_opt_subcommand_desc2_t cmd_table, apr_getopt_option_t const * option_table, \n"
		"    char const * footer, apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_opt_print_help3", _wrap_svn_opt_print_help3, METH_VARARGS, (char *)"\n"
		"svn_opt_print_help3(apr_getopt_t * os, char const * pgm_name, svn_boolean_t print_version, svn_boolean_t quiet, \n"
		"    char const * version_footer, char const * header, svn_opt_subcommand_desc2_t cmd_table, \n"
		"    apr_getopt_option_t const * option_table, char const * footer, \n"
		"    apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_opt_print_help2", _wrap_svn_opt_print_help2, METH_VARARGS, (char *)"\n"
		"svn_opt_print_help2(apr_getopt_t * os, char const * pgm_name, svn_boolean_t print_version, svn_boolean_t quiet, \n"
		"    char const * version_footer, char const * header, svn_opt_subcommand_desc2_t cmd_table, \n"
		"    apr_getopt_option_t const * option_table, char const * footer, \n"
		"    apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_opt_print_help", _wrap_svn_opt_print_help, METH_VARARGS, (char *)"\n"
		"svn_opt_print_help(apr_getopt_t * os, char const * pgm_name, svn_boolean_t print_version, svn_boolean_t quiet, \n"
		"    char const * version_footer, char const * header, svn_opt_subcommand_desc_t cmd_table, \n"
		"    apr_getopt_option_t const * option_table, char const * footer, \n"
		"    apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_cmdline_init", _wrap_svn_cmdline_init, METH_VARARGS, (char *)"svn_cmdline_init(char const * progname, FILE * error_stream) -> int"},
	 { (char *)"svn_cmdline_create_auth_baton", _wrap_svn_cmdline_create_auth_baton, METH_VARARGS, (char *)"\n"
		"svn_cmdline_create_auth_baton(svn_boolean_t non_interactive, char const * username, char const * password, char const * config_dir, \n"
		"    svn_boolean_t no_auth_cache, svn_boolean_t trust_server_cert, \n"
		"    svn_config_t * cfg, svn_cancel_func_t cancel_func, apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_auth_provider_t_cred_kind_set", _wrap_svn_auth_provider_t_cred_kind_set, METH_VARARGS, (char *)"svn_auth_provider_t_cred_kind_set(svn_auth_provider_t self, char const * cred_kind)"},
	 { (char *)"svn_auth_provider_t_cred_kind_get", _wrap_svn_auth_provider_t_cred_kind_get, METH_VARARGS, (char *)"svn_auth_provider_t_cred_kind_get(svn_auth_provider_t self) -> char const *"},
	 { (char *)"svn_auth_provider_t_first_credentials_set", _wrap_svn_auth_provider_t_first_credentials_set, METH_VARARGS, (char *)"svn_auth_provider_t_first_credentials_set(svn_auth_provider_t self, svn_error_t *(*)(void **,void **,void *,apr_hash_t *,...
	 { (char *)"svn_auth_provider_t_first_credentials_get", _wrap_svn_auth_provider_t_first_credentials_get, METH_VARARGS, (char *)"svn_auth_provider_t_first_credentials_get(svn_auth_provider_t self) -> svn_error_t *(*)(void **,void **,void *,apr_hash_t...
	 { (char *)"svn_auth_provider_t_next_credentials_set", _wrap_svn_auth_provider_t_next_credentials_set, METH_VARARGS, (char *)"svn_auth_provider_t_next_credentials_set(svn_auth_provider_t self, svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char...
	 { (char *)"svn_auth_provider_t_next_credentials_get", _wrap_svn_auth_provider_t_next_credentials_get, METH_VARARGS, (char *)"svn_auth_provider_t_next_credentials_get(svn_auth_provider_t self) -> svn_error_t *(*)(void **,void *,void *,apr_hash_t *,c...
	 { (char *)"svn_auth_provider_t_save_credentials_set", _wrap_svn_auth_provider_t_save_credentials_set, METH_VARARGS, (char *)"svn_auth_provider_t_save_credentials_set(svn_auth_provider_t self, svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_...
	 { (char *)"svn_auth_provider_t_save_credentials_get", _wrap_svn_auth_provider_t_save_credentials_get, METH_VARARGS, (char *)"svn_auth_provider_t_save_credentials_get(svn_auth_provider_t self) -> svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_ha...
	 { (char *)"new_svn_auth_provider_t", _wrap_new_svn_auth_provider_t, METH_VARARGS, (char *)"new_svn_auth_provider_t() -> svn_auth_provider_t"},
	 { (char *)"delete_svn_auth_provider_t", _wrap_delete_svn_auth_provider_t, METH_VARARGS, (char *)"delete_svn_auth_provider_t(svn_auth_provider_t self)"},
	 { (char *)"svn_auth_provider_t_swigregister", svn_auth_provider_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_provider_object_t_vtable_set", _wrap_svn_auth_provider_object_t_vtable_set, METH_VARARGS, (char *)"svn_auth_provider_object_t_vtable_set(svn_auth_provider_object_t self, svn_auth_provider_t vtable)"},
	 { (char *)"svn_auth_provider_object_t_vtable_get", _wrap_svn_auth_provider_object_t_vtable_get, METH_VARARGS, (char *)"svn_auth_provider_object_t_vtable_get(svn_auth_provider_object_t self) -> svn_auth_provider_t"},
	 { (char *)"svn_auth_provider_object_t_provider_baton_set", _wrap_svn_auth_provider_object_t_provider_baton_set, METH_VARARGS, (char *)"svn_auth_provider_object_t_provider_baton_set(svn_auth_provider_object_t self, void * provider_baton)"},
	 { (char *)"svn_auth_provider_object_t_provider_baton_get", _wrap_svn_auth_provider_object_t_provider_baton_get, METH_VARARGS, (char *)"svn_auth_provider_object_t_provider_baton_get(svn_auth_provider_object_t self) -> void *"},
	 { (char *)"new_svn_auth_provider_object_t", _wrap_new_svn_auth_provider_object_t, METH_VARARGS, (char *)"new_svn_auth_provider_object_t() -> svn_auth_provider_object_t"},
	 { (char *)"delete_svn_auth_provider_object_t", _wrap_delete_svn_auth_provider_object_t, METH_VARARGS, (char *)"delete_svn_auth_provider_object_t(svn_auth_provider_object_t self)"},
	 { (char *)"svn_auth_provider_object_t_swigregister", svn_auth_provider_object_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_cred_simple_t_username_set", _wrap_svn_auth_cred_simple_t_username_set, METH_VARARGS, (char *)"svn_auth_cred_simple_t_username_set(svn_auth_cred_simple_t self, char const * username)"},
	 { (char *)"svn_auth_cred_simple_t_username_get", _wrap_svn_auth_cred_simple_t_username_get, METH_VARARGS, (char *)"svn_auth_cred_simple_t_username_get(svn_auth_cred_simple_t self) -> char const *"},
	 { (char *)"svn_auth_cred_simple_t_password_set", _wrap_svn_auth_cred_simple_t_password_set, METH_VARARGS, (char *)"svn_auth_cred_simple_t_password_set(svn_auth_cred_simple_t self, char const * password)"},
	 { (char *)"svn_auth_cred_simple_t_password_get", _wrap_svn_auth_cred_simple_t_password_get, METH_VARARGS, (char *)"svn_auth_cred_simple_t_password_get(svn_auth_cred_simple_t self) -> char const *"},
	 { (char *)"svn_auth_cred_simple_t_may_save_set", _wrap_svn_auth_cred_simple_t_may_save_set, METH_VARARGS, (char *)"svn_auth_cred_simple_t_may_save_set(svn_auth_cred_simple_t self, svn_boolean_t may_save)"},
	 { (char *)"svn_auth_cred_simple_t_may_save_get", _wrap_svn_auth_cred_simple_t_may_save_get, METH_VARARGS, (char *)"svn_auth_cred_simple_t_may_save_get(svn_auth_cred_simple_t self) -> svn_boolean_t"},
	 { (char *)"new_svn_auth_cred_simple_t", _wrap_new_svn_auth_cred_simple_t, METH_VARARGS, (char *)"new_svn_auth_cred_simple_t() -> svn_auth_cred_simple_t"},
	 { (char *)"delete_svn_auth_cred_simple_t", _wrap_delete_svn_auth_cred_simple_t, METH_VARARGS, (char *)"delete_svn_auth_cred_simple_t(svn_auth_cred_simple_t self)"},
	 { (char *)"svn_auth_cred_simple_t_swigregister", svn_auth_cred_simple_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_cred_username_t_username_set", _wrap_svn_auth_cred_username_t_username_set, METH_VARARGS, (char *)"svn_auth_cred_username_t_username_set(svn_auth_cred_username_t self, char const * username)"},
	 { (char *)"svn_auth_cred_username_t_username_get", _wrap_svn_auth_cred_username_t_username_get, METH_VARARGS, (char *)"svn_auth_cred_username_t_username_get(svn_auth_cred_username_t self) -> char const *"},
	 { (char *)"svn_auth_cred_username_t_may_save_set", _wrap_svn_auth_cred_username_t_may_save_set, METH_VARARGS, (char *)"svn_auth_cred_username_t_may_save_set(svn_auth_cred_username_t self, svn_boolean_t may_save)"},
	 { (char *)"svn_auth_cred_username_t_may_save_get", _wrap_svn_auth_cred_username_t_may_save_get, METH_VARARGS, (char *)"svn_auth_cred_username_t_may_save_get(svn_auth_cred_username_t self) -> svn_boolean_t"},
	 { (char *)"new_svn_auth_cred_username_t", _wrap_new_svn_auth_cred_username_t, METH_VARARGS, (char *)"new_svn_auth_cred_username_t() -> svn_auth_cred_username_t"},
	 { (char *)"delete_svn_auth_cred_username_t", _wrap_delete_svn_auth_cred_username_t, METH_VARARGS, (char *)"delete_svn_auth_cred_username_t(svn_auth_cred_username_t self)"},
	 { (char *)"svn_auth_cred_username_t_swigregister", svn_auth_cred_username_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_cred_ssl_client_cert_t_cert_file_set", _wrap_svn_auth_cred_ssl_client_cert_t_cert_file_set, METH_VARARGS, (char *)"svn_auth_cred_ssl_client_cert_t_cert_file_set(svn_auth_cred_ssl_client_cert_t self, char const * cert_file)"},
	 { (char *)"svn_auth_cred_ssl_client_cert_t_cert_file_get", _wrap_svn_auth_cred_ssl_client_cert_t_cert_file_get, METH_VARARGS, (char *)"svn_auth_cred_ssl_client_cert_t_cert_file_get(svn_auth_cred_ssl_client_cert_t self) -> char const *"},
	 { (char *)"svn_auth_cred_ssl_client_cert_t_may_save_set", _wrap_svn_auth_cred_ssl_client_cert_t_may_save_set, METH_VARARGS, (char *)"svn_auth_cred_ssl_client_cert_t_may_save_set(svn_auth_cred_ssl_client_cert_t self, svn_boolean_t may_save)"},
	 { (char *)"svn_auth_cred_ssl_client_cert_t_may_save_get", _wrap_svn_auth_cred_ssl_client_cert_t_may_save_get, METH_VARARGS, (char *)"svn_auth_cred_ssl_client_cert_t_may_save_get(svn_auth_cred_ssl_client_cert_t self) -> svn_boolean_t"},
	 { (char *)"new_svn_auth_cred_ssl_client_cert_t", _wrap_new_svn_auth_cred_ssl_client_cert_t, METH_VARARGS, (char *)"new_svn_auth_cred_ssl_client_cert_t() -> svn_auth_cred_ssl_client_cert_t"},
	 { (char *)"delete_svn_auth_cred_ssl_client_cert_t", _wrap_delete_svn_auth_cred_ssl_client_cert_t, METH_VARARGS, (char *)"delete_svn_auth_cred_ssl_client_cert_t(svn_auth_cred_ssl_client_cert_t self)"},
	 { (char *)"svn_auth_cred_ssl_client_cert_t_swigregister", svn_auth_cred_ssl_client_cert_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_cred_ssl_client_cert_pw_t_password_set", _wrap_svn_auth_cred_ssl_client_cert_pw_t_password_set, METH_VARARGS, (char *)"svn_auth_cred_ssl_client_cert_pw_t_password_set(svn_auth_cred_ssl_client_cert_pw_t self, char const * passwor...
	 { (char *)"svn_auth_cred_ssl_client_cert_pw_t_password_get", _wrap_svn_auth_cred_ssl_client_cert_pw_t_password_get, METH_VARARGS, (char *)"svn_auth_cred_ssl_client_cert_pw_t_password_get(svn_auth_cred_ssl_client_cert_pw_t self) -> char const *"},
	 { (char *)"svn_auth_cred_ssl_client_cert_pw_t_may_save_set", _wrap_svn_auth_cred_ssl_client_cert_pw_t_may_save_set, METH_VARARGS, (char *)"svn_auth_cred_ssl_client_cert_pw_t_may_save_set(svn_auth_cred_ssl_client_cert_pw_t self, svn_boolean_t may_sa...
	 { (char *)"svn_auth_cred_ssl_client_cert_pw_t_may_save_get", _wrap_svn_auth_cred_ssl_client_cert_pw_t_may_save_get, METH_VARARGS, (char *)"svn_auth_cred_ssl_client_cert_pw_t_may_save_get(svn_auth_cred_ssl_client_cert_pw_t self) -> svn_boolean_t"},
	 { (char *)"new_svn_auth_cred_ssl_client_cert_pw_t", _wrap_new_svn_auth_cred_ssl_client_cert_pw_t, METH_VARARGS, (char *)"new_svn_auth_cred_ssl_client_cert_pw_t() -> svn_auth_cred_ssl_client_cert_pw_t"},
	 { (char *)"delete_svn_auth_cred_ssl_client_cert_pw_t", _wrap_delete_svn_auth_cred_ssl_client_cert_pw_t, METH_VARARGS, (char *)"delete_svn_auth_cred_ssl_client_cert_pw_t(svn_auth_cred_ssl_client_cert_pw_t self)"},
	 { (char *)"svn_auth_cred_ssl_client_cert_pw_t_swigregister", svn_auth_cred_ssl_client_cert_pw_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_ssl_server_cert_info_t_hostname_set", _wrap_svn_auth_ssl_server_cert_info_t_hostname_set, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_t_hostname_set(svn_auth_ssl_server_cert_info_t self, char const * hostname)"},
	 { (char *)"svn_auth_ssl_server_cert_info_t_hostname_get", _wrap_svn_auth_ssl_server_cert_info_t_hostname_get, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_t_hostname_get(svn_auth_ssl_server_cert_info_t self) -> char const *"},
	 { (char *)"svn_auth_ssl_server_cert_info_t_fingerprint_set", _wrap_svn_auth_ssl_server_cert_info_t_fingerprint_set, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_t_fingerprint_set(svn_auth_ssl_server_cert_info_t self, char const * fingerprin...
	 { (char *)"svn_auth_ssl_server_cert_info_t_fingerprint_get", _wrap_svn_auth_ssl_server_cert_info_t_fingerprint_get, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_t_fingerprint_get(svn_auth_ssl_server_cert_info_t self) -> char const *"},
	 { (char *)"svn_auth_ssl_server_cert_info_t_valid_from_set", _wrap_svn_auth_ssl_server_cert_info_t_valid_from_set, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_t_valid_from_set(svn_auth_ssl_server_cert_info_t self, char const * valid_from)"}...
	 { (char *)"svn_auth_ssl_server_cert_info_t_valid_from_get", _wrap_svn_auth_ssl_server_cert_info_t_valid_from_get, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_t_valid_from_get(svn_auth_ssl_server_cert_info_t self) -> char const *"},
	 { (char *)"svn_auth_ssl_server_cert_info_t_valid_until_set", _wrap_svn_auth_ssl_server_cert_info_t_valid_until_set, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_t_valid_until_set(svn_auth_ssl_server_cert_info_t self, char const * valid_unti...
	 { (char *)"svn_auth_ssl_server_cert_info_t_valid_until_get", _wrap_svn_auth_ssl_server_cert_info_t_valid_until_get, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_t_valid_until_get(svn_auth_ssl_server_cert_info_t self) -> char const *"},
	 { (char *)"svn_auth_ssl_server_cert_info_t_issuer_dname_set", _wrap_svn_auth_ssl_server_cert_info_t_issuer_dname_set, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_t_issuer_dname_set(svn_auth_ssl_server_cert_info_t self, char const * issuer_...
	 { (char *)"svn_auth_ssl_server_cert_info_t_issuer_dname_get", _wrap_svn_auth_ssl_server_cert_info_t_issuer_dname_get, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_t_issuer_dname_get(svn_auth_ssl_server_cert_info_t self) -> char const *"},
	 { (char *)"svn_auth_ssl_server_cert_info_t_ascii_cert_set", _wrap_svn_auth_ssl_server_cert_info_t_ascii_cert_set, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_t_ascii_cert_set(svn_auth_ssl_server_cert_info_t self, char const * ascii_cert)"}...
	 { (char *)"svn_auth_ssl_server_cert_info_t_ascii_cert_get", _wrap_svn_auth_ssl_server_cert_info_t_ascii_cert_get, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_t_ascii_cert_get(svn_auth_ssl_server_cert_info_t self) -> char const *"},
	 { (char *)"new_svn_auth_ssl_server_cert_info_t", _wrap_new_svn_auth_ssl_server_cert_info_t, METH_VARARGS, (char *)"new_svn_auth_ssl_server_cert_info_t() -> svn_auth_ssl_server_cert_info_t"},
	 { (char *)"delete_svn_auth_ssl_server_cert_info_t", _wrap_delete_svn_auth_ssl_server_cert_info_t, METH_VARARGS, (char *)"delete_svn_auth_ssl_server_cert_info_t(svn_auth_ssl_server_cert_info_t self)"},
	 { (char *)"svn_auth_ssl_server_cert_info_t_swigregister", svn_auth_ssl_server_cert_info_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_ssl_server_cert_info_dup", _wrap_svn_auth_ssl_server_cert_info_dup, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_dup(svn_auth_ssl_server_cert_info_t info, apr_pool_t pool) -> svn_auth_ssl_server_cert_info_t"},
	 { (char *)"svn_auth_cred_ssl_server_trust_t_may_save_set", _wrap_svn_auth_cred_ssl_server_trust_t_may_save_set, METH_VARARGS, (char *)"svn_auth_cred_ssl_server_trust_t_may_save_set(svn_auth_cred_ssl_server_trust_t self, svn_boolean_t may_save)"},
	 { (char *)"svn_auth_cred_ssl_server_trust_t_may_save_get", _wrap_svn_auth_cred_ssl_server_trust_t_may_save_get, METH_VARARGS, (char *)"svn_auth_cred_ssl_server_trust_t_may_save_get(svn_auth_cred_ssl_server_trust_t self) -> svn_boolean_t"},
	 { (char *)"svn_auth_cred_ssl_server_trust_t_accepted_failures_set", _wrap_svn_auth_cred_ssl_server_trust_t_accepted_failures_set, METH_VARARGS, (char *)"svn_auth_cred_ssl_server_trust_t_accepted_failures_set(svn_auth_cred_ssl_server_trust_t self, a...
	 { (char *)"svn_auth_cred_ssl_server_trust_t_accepted_failures_get", _wrap_svn_auth_cred_ssl_server_trust_t_accepted_failures_get, METH_VARARGS, (char *)"svn_auth_cred_ssl_server_trust_t_accepted_failures_get(svn_auth_cred_ssl_server_trust_t self) -...
	 { (char *)"new_svn_auth_cred_ssl_server_trust_t", _wrap_new_svn_auth_cred_ssl_server_trust_t, METH_VARARGS, (char *)"new_svn_auth_cred_ssl_server_trust_t() -> svn_auth_cred_ssl_server_trust_t"},
	 { (char *)"delete_svn_auth_cred_ssl_server_trust_t", _wrap_delete_svn_auth_cred_ssl_server_trust_t, METH_VARARGS, (char *)"delete_svn_auth_cred_ssl_server_trust_t(svn_auth_cred_ssl_server_trust_t self)"},
	 { (char *)"svn_auth_cred_ssl_server_trust_t_swigregister", svn_auth_cred_ssl_server_trust_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_open", _wrap_svn_auth_open, METH_VARARGS, (char *)"svn_auth_open(apr_array_header_t providers, apr_pool_t pool)"},
	 { (char *)"svn_auth_set_parameter", _wrap_svn_auth_set_parameter, METH_VARARGS, (char *)"svn_auth_set_parameter(svn_auth_baton_t * auth_baton, char const * name, void const * value)"},
	 { (char *)"svn_auth_first_credentials", _wrap_svn_auth_first_credentials, METH_VARARGS, (char *)"\n"
		"svn_auth_first_credentials(char const * cred_kind, char const * realmstring, svn_auth_baton_t * auth_baton, \n"
		"    apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_auth_next_credentials", _wrap_svn_auth_next_credentials, METH_VARARGS, (char *)"svn_auth_next_credentials(svn_auth_iterstate_t * state, apr_pool_t pool) -> svn_error_t"},
	 { (char *)"svn_auth_save_credentials", _wrap_svn_auth_save_credentials, METH_VARARGS, (char *)"svn_auth_save_credentials(svn_auth_iterstate_t * state, apr_pool_t pool) -> svn_error_t"},
	 { (char *)"svn_auth_forget_credentials", _wrap_svn_auth_forget_credentials, METH_VARARGS, (char *)"\n"
		"svn_auth_forget_credentials(svn_auth_baton_t * auth_baton, char const * cred_kind, char const * realmstring, \n"
		"    apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_auth_get_simple_prompt_provider", _wrap_svn_auth_get_simple_prompt_provider, METH_VARARGS, (char *)"svn_auth_get_simple_prompt_provider(svn_auth_simple_prompt_func_t prompt_func, int retry_limit, apr_pool_t pool)"},
	 { (char *)"svn_auth_get_username_prompt_provider", _wrap_svn_auth_get_username_prompt_provider, METH_VARARGS, (char *)"svn_auth_get_username_prompt_provider(svn_auth_username_prompt_func_t prompt_func, int retry_limit, apr_pool_t pool)"},
	 { (char *)"svn_auth_get_simple_provider2", _wrap_svn_auth_get_simple_provider2, METH_VARARGS, (char *)"svn_auth_get_simple_provider2(svn_auth_plaintext_prompt_func_t plaintext_prompt_func, void * prompt_baton, apr_pool_t pool)"},
	 { (char *)"svn_auth_get_simple_provider", _wrap_svn_auth_get_simple_provider, METH_VARARGS, (char *)"svn_auth_get_simple_provider(apr_pool_t pool)"},
	 { (char *)"svn_auth_get_platform_specific_provider", _wrap_svn_auth_get_platform_specific_provider, METH_VARARGS, (char *)"svn_auth_get_platform_specific_provider(char const * provider_name, char const * provider_type, apr_pool_t pool) -> svn_error...
	 { (char *)"svn_auth_get_platform_specific_client_providers", _wrap_svn_auth_get_platform_specific_client_providers, METH_VARARGS, (char *)"svn_auth_get_platform_specific_client_providers(svn_config_t * config, apr_pool_t pool) -> svn_error_t"},
	 { (char *)"svn_auth_get_username_provider", _wrap_svn_auth_get_username_provider, METH_VARARGS, (char *)"svn_auth_get_username_provider(apr_pool_t pool)"},
	 { (char *)"svn_auth_get_ssl_server_trust_file_provider", _wrap_svn_auth_get_ssl_server_trust_file_provider, METH_VARARGS, (char *)"svn_auth_get_ssl_server_trust_file_provider(apr_pool_t pool)"},
	 { (char *)"svn_auth_get_ssl_client_cert_file_provider", _wrap_svn_auth_get_ssl_client_cert_file_provider, METH_VARARGS, (char *)"svn_auth_get_ssl_client_cert_file_provider(apr_pool_t pool)"},
	 { (char *)"svn_auth_get_ssl_client_cert_pw_file_provider2", _wrap_svn_auth_get_ssl_client_cert_pw_file_provider2, METH_VARARGS, (char *)"\n"
		"svn_auth_get_ssl_client_cert_pw_file_provider2(svn_auth_plaintext_passphrase_prompt_func_t plaintext_passphrase_prompt_func, void * prompt_baton, \n"
		"    apr_pool_t pool)\n"
		""},
	 { (char *)"svn_auth_get_ssl_client_cert_pw_file_provider", _wrap_svn_auth_get_ssl_client_cert_pw_file_provider, METH_VARARGS, (char *)"svn_auth_get_ssl_client_cert_pw_file_provider(apr_pool_t pool)"},
	 { (char *)"svn_auth_get_ssl_server_trust_prompt_provider", _wrap_svn_auth_get_ssl_server_trust_prompt_provider, METH_VARARGS, (char *)"svn_auth_get_ssl_server_trust_prompt_provider(svn_auth_ssl_server_trust_prompt_func_t prompt_func, apr_pool_t poo...
	 { (char *)"svn_auth_get_ssl_client_cert_prompt_provider", _wrap_svn_auth_get_ssl_client_cert_prompt_provider, METH_VARARGS, (char *)"svn_auth_get_ssl_client_cert_prompt_provider(svn_auth_ssl_client_cert_prompt_func_t prompt_func, int retry_limit, a...
	 { (char *)"svn_auth_get_ssl_client_cert_pw_prompt_provider", _wrap_svn_auth_get_ssl_client_cert_pw_prompt_provider, METH_VARARGS, (char *)"svn_auth_get_ssl_client_cert_pw_prompt_provider(svn_auth_ssl_client_cert_pw_prompt_func_t prompt_func, int re...
	 { (char *)"svn_auth_baton_t_swigregister", svn_auth_baton_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_iterstate_t_swigregister", svn_auth_iterstate_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_provider_invoke_first_credentials", _wrap_svn_auth_provider_invoke_first_credentials, METH_VARARGS, (char *)"\n"
		"svn_auth_provider_invoke_first_credentials(svn_auth_provider_t _obj, void * provider_baton, apr_hash_t parameters, char const * realmstring, \n"
		"    apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_auth_provider_invoke_next_credentials", _wrap_svn_auth_provider_invoke_next_credentials, METH_VARARGS, (char *)"\n"
		"svn_auth_provider_invoke_next_credentials(svn_auth_provider_t _obj, void * iter_baton, void * provider_baton, apr_hash_t parameters, \n"
		"    char const * realmstring, apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_auth_provider_invoke_save_credentials", _wrap_svn_auth_provider_invoke_save_credentials, METH_VARARGS, (char *)"\n"
		"svn_auth_provider_invoke_save_credentials(svn_auth_provider_t _obj, void * credentials, void * provider_baton, apr_hash_t parameters, \n"
		"    char const * realmstring, apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_auth_invoke_simple_provider_func", _wrap_svn_auth_invoke_simple_provider_func, METH_VARARGS, (char *)"svn_auth_invoke_simple_provider_func(svn_auth_simple_provider_func_t _obj, apr_pool_t pool)"},
	 { (char *)"svn_auth_invoke_ssl_client_cert_pw_provider_func", _wrap_svn_auth_invoke_ssl_client_cert_pw_provider_func, METH_VARARGS, (char *)"svn_auth_invoke_ssl_client_cert_pw_provider_func(svn_auth_ssl_client_cert_pw_provider_func_t _obj, apr_pool...
	 { (char *)"svn_auth_invoke_simple_prompt_func", _wrap_svn_auth_invoke_simple_prompt_func, METH_VARARGS, (char *)"\n"
		"svn_auth_invoke_simple_prompt_func(svn_auth_simple_prompt_func_t _obj, void * baton, char const * realm, char const * username, \n"
		"    svn_boolean_t may_save, apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_auth_invoke_username_prompt_func", _wrap_svn_auth_invoke_username_prompt_func, METH_VARARGS, (char *)"\n"
		"svn_auth_invoke_username_prompt_func(svn_auth_username_prompt_func_t _obj, void * baton, char const * realm, svn_boolean_t may_save, \n"
		"    apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_auth_invoke_ssl_server_trust_prompt_func", _wrap_svn_auth_invoke_ssl_server_trust_prompt_func, METH_VARARGS, (char *)"\n"
		"svn_auth_invoke_ssl_server_trust_prompt_func(svn_auth_ssl_server_trust_prompt_func_t _obj, void * baton, char const * realm, apr_uint32_t failures, \n"
		"    svn_auth_ssl_server_cert_info_t cert_info, svn_boolean_t may_save, \n"
		"    apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_auth_invoke_ssl_client_cert_prompt_func", _wrap_svn_auth_invoke_ssl_client_cert_prompt_func, METH_VARARGS, (char *)"\n"
		"svn_auth_invoke_ssl_client_cert_prompt_func(svn_auth_ssl_client_cert_prompt_func_t _obj, void * baton, char const * realm, svn_boolean_t may_save, \n"
		"    apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_auth_invoke_ssl_client_cert_pw_prompt_func", _wrap_svn_auth_invoke_ssl_client_cert_pw_prompt_func, METH_VARARGS, (char *)"\n"
		"svn_auth_invoke_ssl_client_cert_pw_prompt_func(svn_auth_ssl_client_cert_pw_prompt_func_t _obj, void * baton, char const * realm, \n"
		"    svn_boolean_t may_save, apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_auth_invoke_plaintext_prompt_func", _wrap_svn_auth_invoke_plaintext_prompt_func, METH_VARARGS, (char *)"svn_auth_invoke_plaintext_prompt_func(svn_auth_plaintext_prompt_func_t _obj, char const * realmstring, void * baton, apr_pool_t p...
	 { (char *)"svn_auth_invoke_plaintext_passphrase_prompt_func", _wrap_svn_auth_invoke_plaintext_passphrase_prompt_func, METH_VARARGS, (char *)"\n"
		"svn_auth_invoke_plaintext_passphrase_prompt_func(svn_auth_plaintext_passphrase_prompt_func_t _obj, char const * realmstring, void * baton, \n"
		"    apr_pool_t pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_auth_simple_provider_func_t_swigregister", svn_auth_simple_provider_func_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_ssl_client_cert_pw_provider_func_t_swigregister", svn_auth_ssl_client_cert_pw_provider_func_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_simple_prompt_func_t_swigregister", svn_auth_simple_prompt_func_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_username_prompt_func_t_swigregister", svn_auth_username_prompt_func_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_ssl_server_trust_prompt_func_t_swigregister", svn_auth_ssl_server_trust_prompt_func_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_ssl_client_cert_prompt_func_t_swigregister", svn_auth_ssl_client_cert_prompt_func_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_ssl_client_cert_pw_prompt_func_t_swigregister", svn_auth_ssl_client_cert_pw_prompt_func_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_plaintext_prompt_func_t_swigregister", svn_auth_plaintext_prompt_func_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_plaintext_passphrase_prompt_func_t_swigregister", svn_auth_plaintext_passphrase_prompt_func_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_auth_gnome_keyring_unlock_prompt_func_t_swigregister", svn_auth_gnome_keyring_unlock_prompt_func_t_swigregister, METH_VARARGS, NULL},
	 { (char *)"svn_config_get_config", _wrap_svn_config_get_config, METH_VARARGS, (char *)"svn_config_get_config(char const * config_dir, apr_pool_t pool) -> svn_error_t"},
	 { (char *)"svn_config_create2", _wrap_svn_config_create2, METH_VARARGS, (char *)"\n"
		"svn_config_create2(svn_boolean_t section_names_case_sensitive, svn_boolean_t option_names_case_sensitive, \n"
		"    apr_pool_t result_pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_config_create", _wrap_svn_config_create, METH_VARARGS, (char *)"svn_config_create(svn_boolean_t section_names_case_sensitive, apr_pool_t result_pool) -> svn_error_t"},
	 { (char *)"svn_config_read3", _wrap_svn_config_read3, METH_VARARGS, (char *)"\n"
		"svn_config_read3(char const * file, svn_boolean_t must_exist, svn_boolean_t section_names_case_sensitive, \n"
		"    svn_boolean_t option_names_case_sensitive, apr_pool_t result_pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_config_read2", _wrap_svn_config_read2, METH_VARARGS, (char *)"\n"
		"svn_config_read2(char const * file, svn_boolean_t must_exist, svn_boolean_t section_names_case_sensitive, \n"
		"    apr_pool_t result_pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_config_read", _wrap_svn_config_read, METH_VARARGS, (char *)"svn_config_read(char const * file, svn_boolean_t must_exist, apr_pool_t result_pool) -> svn_error_t"},
	 { (char *)"svn_config_parse", _wrap_svn_config_parse, METH_VARARGS, (char *)"\n"
		"svn_config_parse(svn_stream_t * stream, svn_boolean_t section_names_case_sensitive, svn_boolean_t option_names_case_sensitive, \n"
		"    apr_pool_t result_pool) -> svn_error_t\n"
		""},
	 { (char *)"svn_config_merge", _wrap_svn_config_merge, METH_VARARGS, (char *)"svn_config_merge(svn_config_t * cfg, char const * file, svn_boolean_t must_exist) -> svn_error_t"},

( run in 0.887 second using v1.01-cache-2.11-cpan-f6376fbd888 )