class Openwsman::Client

SWIGINTERN VALUE _wrap_new_Client(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs;
  if (argc > 6) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Client__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Client__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Client.new", 
    "    Client.new(char const *uri)\n"
    "    Client.new(char const *hostname, int const port, char const *path, char const *scheme, char const *username, char const *password)\n");
  
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_build_envelope_from_response(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","build_envelope_from_response", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  result = (WsXmlDocH)_WsManClient_build_envelope_from_response(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_create(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  char *arg6 = (char *) "utf-8" ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","create", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","create", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","create", 3, argv[1] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","create", 4, argv[2] ));
  }
  arg4 = (char *)(buf4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","create", 5, argv[3] ));
  } 
  arg5 = (size_t)(val5);
  if (argc > 4) {
    res6 = SWIG_AsCharPtrAndSize(argv[4], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char const *","create", 6, argv[4] ));
    }
    arg6 = (char *)(buf6);
  }
  result = (WsXmlDocH)_WsManClient_create(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,(char const *)arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_delete(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","delete", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","delete", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","delete", 3, argv[1] ));
  }
  arg3 = (char *)(buf3);
  result = (WsXmlDocH)_WsManClient_delete(arg1,arg2,(char const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_delete_from_epr(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  epr_t *arg3 = (epr_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","delete_from_epr", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","delete_from_epr", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_epr_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "epr_t *","delete_from_epr", 3, argv[1] )); 
  }
  arg3 = (epr_t *)(argp3);
  result = (WsXmlDocH)_WsManClient_delete_from_epr(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_dumpfilee___(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","set_dumpfile", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  {
    struct rb_io_t *fptr;
    
    
    
    Check_Type(argv[0], T_FILE);
    GetOpenFile(argv[0], fptr);
    /*rb_io_check_writable(fptr);*/
    
    arg2 = rb_io_stdio_file(fptr);
    
    
    
  }
  _WsManClient_set_dumpfile(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_encoding(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","encoding", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  result = (char *)_WsManClient_encoding(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_encodinge___(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","set_encoding", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","set_encoding", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManClient_set_encoding(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_enumerate(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  filter_t *arg3 = (filter_t *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","enumerate", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","enumerate", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_filter_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "filter_t *","enumerate", 3, argv[1] )); 
  }
  arg3 = (filter_t *)(argp3);
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","enumerate", 4, argv[2] ));
  }
  arg4 = (char *)(buf4);
  result = (WsXmlDocH)_WsManClient_enumerate(arg1,arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return vresult;
fail:
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_fault_string(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","fault_string", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  result = (char *)_WsManClient_fault_string(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_get(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","get", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","get", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","get", 3, argv[1] ));
  }
  arg3 = (char *)(buf3);
  result = (WsXmlDocH)_WsManClient_get(arg1,arg2,(char const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_get_from_epr(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  epr_t *arg3 = (epr_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","get_from_epr", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","get_from_epr", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_epr_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "epr_t *","get_from_epr", 3, argv[1] )); 
  }
  arg3 = (epr_t *)(argp3);
  result = (WsXmlDocH)_WsManClient_get_from_epr(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_host(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","host", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  result = (char *)_WsManClient_host(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_identify(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","identify", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","identify", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  result = (WsXmlDocH)_WsManClient_identify(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_invoke(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  WsXmlDocH arg5 = (WsXmlDocH) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","invoke", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","invoke", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","invoke", 3, argv[1] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","invoke", 4, argv[2] ));
  }
  arg4 = (char *)(buf4);
  if (argc > 3) {
    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p__WsXmlDoc, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "WsXmlDocH","invoke", 5, argv[3] )); 
    }
    arg5 = (WsXmlDocH)(argp5);
  }
  result = (WsXmlDocH)_WsManClient_invoke(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_last_error(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","last_error", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  result = (int)_WsManClient_last_error(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_password(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","password", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  result = (char *)_WsManClient_password(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_path(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","path", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  result = (char *)_WsManClient_path(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_port(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","port", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  result = (int)_WsManClient_port(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_pull(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  filter_t *arg3 = (filter_t *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","pull", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","pull", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_filter_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "filter_t *","pull", 3, argv[1] )); 
  }
  arg3 = (filter_t *)(argp3);
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","pull", 4, argv[2] ));
  }
  arg4 = (char *)(buf4);
  res5 = SWIG_AsCharPtrAndSize(argv[3], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","pull", 5, argv[3] ));
  }
  arg5 = (char *)(buf5);
  result = (WsXmlDocH)_WsManClient_pull(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
  return vresult;
fail:
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_put(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  char *arg6 = (char *) "utf-8" ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","put", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","put", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","put", 3, argv[1] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","put", 4, argv[2] ));
  }
  arg4 = (char *)(buf4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","put", 5, argv[3] ));
  } 
  arg5 = (size_t)(val5);
  if (argc > 4) {
    res6 = SWIG_AsCharPtrAndSize(argv[4], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char const *","put", 6, argv[4] ));
    }
    arg6 = (char *)(buf6);
  }
  result = (WsXmlDocH)_WsManClient_put(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,(char const *)arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_release(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","release", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","release", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","release", 3, argv[1] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","release", 4, argv[2] ));
  }
  arg4 = (char *)(buf4);
  result = (WsXmlDocH)_WsManClient_release(arg1,arg2,(char const *)arg3,(char const *)arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_renew(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","renew", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","renew", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","renew", 3, argv[1] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","renew", 4, argv[2] ));
  }
  arg4 = (char *)(buf4);
  result = (WsXmlDocH)_WsManClient_renew(arg1,arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_response_code(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","response_code", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  result = (long)_WsManClient_response_code(arg1);
  vresult = SWIG_From_long((long)(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_scheme(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","scheme", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  result = (char *)_WsManClient_scheme(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_send_request(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  WsXmlDocH arg2 = (WsXmlDocH) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","send_request", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "WsXmlDocH","send_request", 2, argv[0] )); 
  }
  arg2 = (WsXmlDocH)(argp2);
  result = (int)_WsManClient_send_request(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_subscribe(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  filter_t *arg3 = (filter_t *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","subscribe", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","subscribe", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_filter_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "filter_t *","subscribe", 3, argv[1] )); 
  }
  arg3 = (filter_t *)(argp3);
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","subscribe", 4, argv[2] ));
  }
  arg4 = (char *)(buf4);
  result = (WsXmlDocH)_WsManClient_subscribe(arg1,arg2,arg3,(char const *)arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return vresult;
fail:
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_transport(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  WsManTransport *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","transport", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  result = (WsManTransport *)_WsManClient_transport(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsManTransport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_unsubscribe(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  client_opt_t *arg2 = (client_opt_t *) 0 ;
  filter_t *arg3 = (filter_t *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  WsXmlDocH result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","unsubscribe", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_client_opt_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "client_opt_t *","unsubscribe", 2, argv[0] )); 
  }
  arg2 = (client_opt_t *)(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_filter_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "filter_t *","unsubscribe", 3, argv[1] )); 
  }
  arg3 = (filter_t *)(argp3);
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","unsubscribe", 4, argv[2] ));
  }
  arg4 = (char *)(buf4);
  res5 = SWIG_AsCharPtrAndSize(argv[3], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","unsubscribe", 5, argv[3] ));
  }
  arg5 = (char *)(buf5);
  result = (WsXmlDocH)_WsManClient_unsubscribe(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
  return vresult;
fail:
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Client_user(int argc, VALUE *argv, VALUE self) {
  struct _WsManClient *arg1 = (struct _WsManClient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManClient, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManClient *","user", 1, self )); 
  }
  arg1 = (struct _WsManClient *)(argp1);
  result = (char *)_WsManClient_user(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}