Class: Ctp::CThostFtdcTraderApi

Inherits:

Object

Object
Ctp::CThostFtdcTraderApi

show all

Defined in:: ext/ctp/ctp.cxx

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.CreateFtdcTraderApi(*args, self) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199141

SWIGINTERN VALUE _wrap_CThostFtdcTraderApi_CreateFtdcTraderApi(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_CThostFtdcTraderApi_CreateFtdcTraderApi__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CThostFtdcTraderApi_CreateFtdcTraderApi__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CThostFtdcTraderApi.CreateFtdcTraderApi", 
    "    CThostFtdcTraderApi CThostFtdcTraderApi.CreateFtdcTraderApi(char const *pszFlowPath)\n"
    "    CThostFtdcTraderApi * CThostFtdcTraderApi.CreateFtdcTraderApi()\n");
  
  return Qnil;
}

.GetApiVersion(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199172

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_GetApiVersion(int argc, VALUE *argv, VALUE self) {
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (char *)CThostFtdcTraderApi::GetApiVersion();
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

Instance Method Details

#GetTradingDay(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199254

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_GetTradingDay(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","GetTradingDay", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  result = (char *)(arg1)->GetTradingDay();
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

#Init(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199209

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_Init(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","Init", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  (arg1)->Init();
  return Qnil;
fail:
  return Qnil;
}

#Join(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199230

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_Join(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","Join", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  result = (int)(arg1)->Join();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#RegisterFensUserInfo(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199342

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_RegisterFensUserInfo(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcFensUserInfoField *arg2 = (CThostFtdcFensUserInfoField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","RegisterFensUserInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcFensUserInfoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcFensUserInfoField *","RegisterFensUserInfo", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcFensUserInfoField * >(argp2);
  (arg1)->RegisterFensUserInfo(arg2);
  return Qnil;
fail:
  return Qnil;
}

#RegisterFront(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199278

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_RegisterFront(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","RegisterFront", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","RegisterFront", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->RegisterFront(arg2);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}

#RegisterNameServer(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199310

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_RegisterNameServer(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","RegisterNameServer", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","RegisterNameServer", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->RegisterNameServer(arg2);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}

#RegisterSpi(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199371

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_RegisterSpi(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcTraderSpi *arg2 = (CThostFtdcTraderSpi *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","RegisterSpi", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcTraderSpi, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcTraderSpi *","RegisterSpi", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcTraderSpi * >(argp2);
  (arg1)->RegisterSpi(arg2);
  return Qnil;
fail:
  return Qnil;
}

#Release(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199188

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_Release(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","Release", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  (arg1)->Release();
  return Qnil;
fail:
  return Qnil;
}

#ReqAuthenticate(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199458

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqAuthenticate(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcReqAuthenticateField *arg2 = (CThostFtdcReqAuthenticateField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqAuthenticate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcReqAuthenticateField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcReqAuthenticateField *","ReqAuthenticate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcReqAuthenticateField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqAuthenticate", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqAuthenticate(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqCombActionInsert(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200178

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqCombActionInsert(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcInputCombActionField *arg2 = (CThostFtdcInputCombActionField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqCombActionInsert", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcInputCombActionField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcInputCombActionField *","ReqCombActionInsert", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcInputCombActionField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqCombActionInsert", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqCombActionInsert(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqExecOrderAction(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200018

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqExecOrderAction(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcInputExecOrderActionField *arg2 = (CThostFtdcInputExecOrderActionField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqExecOrderAction", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcInputExecOrderActionField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcInputExecOrderActionField *","ReqExecOrderAction", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcInputExecOrderActionField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqExecOrderAction", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqExecOrderAction(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqExecOrderInsert(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199978

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqExecOrderInsert(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcInputExecOrderField *arg2 = (CThostFtdcInputExecOrderField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqExecOrderInsert", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcInputExecOrderField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcInputExecOrderField *","ReqExecOrderInsert", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcInputExecOrderField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqExecOrderInsert", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqExecOrderInsert(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqForQuoteInsert(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200058

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqForQuoteInsert(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcInputForQuoteField *arg2 = (CThostFtdcInputForQuoteField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqForQuoteInsert", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcInputForQuoteField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcInputForQuoteField *","ReqForQuoteInsert", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcInputForQuoteField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqForQuoteInsert", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqForQuoteInsert(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqFromBankToFutureByFuture(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201898

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqFromBankToFutureByFuture(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcReqTransferField *arg2 = (CThostFtdcReqTransferField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqFromBankToFutureByFuture", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","ReqFromBankToFutureByFuture", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcReqTransferField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqFromBankToFutureByFuture", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqFromBankToFutureByFuture(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqFromFutureToBankByFuture(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201938

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqFromFutureToBankByFuture(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcReqTransferField *arg2 = (CThostFtdcReqTransferField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqFromFutureToBankByFuture", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","ReqFromFutureToBankByFuture", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcReqTransferField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqFromFutureToBankByFuture", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqFromFutureToBankByFuture(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqOrderAction(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199778

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqOrderAction(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcInputOrderActionField *arg2 = (CThostFtdcInputOrderActionField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqOrderAction", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcInputOrderActionField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcInputOrderActionField *","ReqOrderAction", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcInputOrderActionField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqOrderAction", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqOrderAction(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqOrderInsert(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199658

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqOrderInsert(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcInputOrderField *arg2 = (CThostFtdcInputOrderField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqOrderInsert", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcInputOrderField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcInputOrderField *","ReqOrderInsert", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcInputOrderField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqOrderInsert", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqOrderInsert(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqParkedOrderAction(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199738

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqParkedOrderAction(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcParkedOrderActionField *arg2 = (CThostFtdcParkedOrderActionField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqParkedOrderAction", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcParkedOrderActionField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcParkedOrderActionField *","ReqParkedOrderAction", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcParkedOrderActionField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqParkedOrderAction", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqParkedOrderAction(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqParkedOrderInsert(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199698

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqParkedOrderInsert(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcParkedOrderField *arg2 = (CThostFtdcParkedOrderField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqParkedOrderInsert", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcParkedOrderField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcParkedOrderField *","ReqParkedOrderInsert", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcParkedOrderField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqParkedOrderInsert", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqParkedOrderInsert(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryAccountregister(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201578

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryAccountregister(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryAccountregisterField *arg2 = (CThostFtdcQryAccountregisterField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryAccountregister", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryAccountregisterField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryAccountregisterField *","ReqQryAccountregister", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryAccountregisterField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryAccountregister", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryAccountregister(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryBrokerTradingAlgos(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201818

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryBrokerTradingAlgos(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryBrokerTradingAlgosField *arg2 = (CThostFtdcQryBrokerTradingAlgosField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryBrokerTradingAlgos", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryBrokerTradingAlgosField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryBrokerTradingAlgosField *","ReqQryBrokerTradingAlgos", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryBrokerTradingAlgosField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryBrokerTradingAlgos", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryBrokerTradingAlgos(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryBrokerTradingParams(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201778

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryBrokerTradingParams(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryBrokerTradingParamsField *arg2 = (CThostFtdcQryBrokerTradingParamsField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryBrokerTradingParams", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryBrokerTradingParamsField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryBrokerTradingParamsField *","ReqQryBrokerTradingParams", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryBrokerTradingParamsField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryBrokerTradingParams", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryBrokerTradingParams(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryCFMMCTradingAccountKey(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200938

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryCFMMCTradingAccountKey(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryCFMMCTradingAccountKeyField *arg2 = (CThostFtdcQryCFMMCTradingAccountKeyField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryCFMMCTradingAccountKey", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryCFMMCTradingAccountKeyField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryCFMMCTradingAccountKeyField *","ReqQryCFMMCTradingAccountKey", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryCFMMCTradingAccountKeyField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryCFMMCTradingAccountKey", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryCFMMCTradingAccountKey(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryCombAction(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201498

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryCombAction(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryCombActionField *arg2 = (CThostFtdcQryCombActionField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryCombAction", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryCombActionField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryCombActionField *","ReqQryCombAction", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryCombActionField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryCombAction", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryCombAction(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryCombInstrumentGuard(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201458

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryCombInstrumentGuard(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryCombInstrumentGuardField *arg2 = (CThostFtdcQryCombInstrumentGuardField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryCombInstrumentGuard", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryCombInstrumentGuardField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryCombInstrumentGuardField *","ReqQryCombInstrumentGuard", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryCombInstrumentGuardField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryCombInstrumentGuard", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryCombInstrumentGuard(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryContractBank(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201618

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryContractBank(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryContractBankField *arg2 = (CThostFtdcQryContractBankField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryContractBank", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryContractBankField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryContractBankField *","ReqQryContractBank", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryContractBankField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryContractBank", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryContractBank(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryDepthMarketData(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200658

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryDepthMarketData(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryDepthMarketDataField *arg2 = (CThostFtdcQryDepthMarketDataField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryDepthMarketData", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryDepthMarketDataField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryDepthMarketDataField *","ReqQryDepthMarketData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryDepthMarketDataField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryDepthMarketData", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryDepthMarketData(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryEWarrantOffset(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200978

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryEWarrantOffset(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryEWarrantOffsetField *arg2 = (CThostFtdcQryEWarrantOffsetField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryEWarrantOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryEWarrantOffsetField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryEWarrantOffsetField *","ReqQryEWarrantOffset", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryEWarrantOffsetField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryEWarrantOffset", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryEWarrantOffset(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryExchange(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200538

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryExchange(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryExchangeField *arg2 = (CThostFtdcQryExchangeField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryExchange", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryExchangeField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryExchangeField *","ReqQryExchange", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryExchangeField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryExchange", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryExchange(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryExchangeMarginRate(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201058

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryExchangeMarginRate(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryExchangeMarginRateField *arg2 = (CThostFtdcQryExchangeMarginRateField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryExchangeMarginRate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryExchangeMarginRateField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryExchangeMarginRateField *","ReqQryExchangeMarginRate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryExchangeMarginRateField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryExchangeMarginRate", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryExchangeMarginRate(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryExchangeMarginRateAdjust(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201098

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryExchangeMarginRateAdjust(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryExchangeMarginRateAdjustField *arg2 = (CThostFtdcQryExchangeMarginRateAdjustField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryExchangeMarginRateAdjust", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryExchangeMarginRateAdjustField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryExchangeMarginRateAdjustField *","ReqQryExchangeMarginRateAdjust", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryExchangeMarginRateAdjustField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryExchangeMarginRateAdjust", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryExchangeMarginRateAdjust(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryExchangeRate(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201138

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryExchangeRate(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryExchangeRateField *arg2 = (CThostFtdcQryExchangeRateField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryExchangeRate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryExchangeRateField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryExchangeRateField *","ReqQryExchangeRate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryExchangeRateField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryExchangeRate", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryExchangeRate(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryExecOrder(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201338

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryExecOrder(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryExecOrderField *arg2 = (CThostFtdcQryExecOrderField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryExecOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryExecOrderField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryExecOrderField *","ReqQryExecOrder", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryExecOrderField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryExecOrder", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryExecOrder(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryForQuote(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201378

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryForQuote(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryForQuoteField *arg2 = (CThostFtdcQryForQuoteField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryForQuote", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryForQuoteField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryForQuoteField *","ReqQryForQuote", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryForQuoteField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryForQuote", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryForQuote(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryInstrument(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200618

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryInstrument(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryInstrumentField *arg2 = (CThostFtdcQryInstrumentField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryInstrument", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryInstrumentField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryInstrumentField *","ReqQryInstrument", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryInstrumentField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryInstrument", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryInstrument(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryInstrumentCommissionRate(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200498

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryInstrumentCommissionRate(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryInstrumentCommissionRateField *arg2 = (CThostFtdcQryInstrumentCommissionRateField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryInstrumentCommissionRate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryInstrumentCommissionRateField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryInstrumentCommissionRateField *","ReqQryInstrumentCommissionRate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryInstrumentCommissionRateField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryInstrumentCommissionRate", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryInstrumentCommissionRate(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryInstrumentMarginRate(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200458

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryInstrumentMarginRate(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryInstrumentMarginRateField *arg2 = (CThostFtdcQryInstrumentMarginRateField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryInstrumentMarginRate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryInstrumentMarginRateField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryInstrumentMarginRateField *","ReqQryInstrumentMarginRate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryInstrumentMarginRateField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryInstrumentMarginRate", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryInstrumentMarginRate(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryInvestor(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200378

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryInvestor(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryInvestorField *arg2 = (CThostFtdcQryInvestorField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryInvestor", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryInvestorField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryInvestorField *","ReqQryInvestor", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryInvestorField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryInvestor", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryInvestor(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryInvestorPosition(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200298

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryInvestorPosition(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryInvestorPositionField *arg2 = (CThostFtdcQryInvestorPositionField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryInvestorPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryInvestorPositionField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryInvestorPositionField *","ReqQryInvestorPosition", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryInvestorPositionField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryInvestorPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryInvestorPosition(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryInvestorPositionCombineDetail(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200898

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryInvestorPositionCombineDetail(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryInvestorPositionCombineDetailField *arg2 = (CThostFtdcQryInvestorPositionCombineDetailField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryInvestorPositionCombineDetail", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryInvestorPositionCombineDetailField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryInvestorPositionCombineDetailField *","ReqQryInvestorPositionCombineDetail", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryInvestorPositionCombineDetailField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryInvestorPositionCombineDetail", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryInvestorPositionCombineDetail(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryInvestorPositionDetail(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200778

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryInvestorPositionDetail(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryInvestorPositionDetailField *arg2 = (CThostFtdcQryInvestorPositionDetailField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryInvestorPositionDetail", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryInvestorPositionDetailField *","ReqQryInvestorPositionDetail", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryInvestorPositionDetailField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryInvestorPositionDetail", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryInvestorPositionDetail(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryInvestorProductGroupMargin(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201018

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryInvestorProductGroupMargin(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryInvestorProductGroupMarginField *arg2 = (CThostFtdcQryInvestorProductGroupMarginField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryInvestorProductGroupMargin", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryInvestorProductGroupMarginField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryInvestorProductGroupMarginField *","ReqQryInvestorProductGroupMargin", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryInvestorProductGroupMarginField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryInvestorProductGroupMargin", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryInvestorProductGroupMargin(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryNotice(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200818

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryNotice(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryNoticeField *arg2 = (CThostFtdcQryNoticeField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryNotice", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryNoticeField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryNoticeField *","ReqQryNotice", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryNoticeField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryNotice", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryNotice(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryOptionInstrCommRate(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201298

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryOptionInstrCommRate(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryOptionInstrCommRateField *arg2 = (CThostFtdcQryOptionInstrCommRateField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryOptionInstrCommRate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryOptionInstrCommRateField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryOptionInstrCommRateField *","ReqQryOptionInstrCommRate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryOptionInstrCommRateField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryOptionInstrCommRate", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryOptionInstrCommRate(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryOptionInstrTradeCost(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201258

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryOptionInstrTradeCost(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryOptionInstrTradeCostField *arg2 = (CThostFtdcQryOptionInstrTradeCostField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryOptionInstrTradeCost", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryOptionInstrTradeCostField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryOptionInstrTradeCostField *","ReqQryOptionInstrTradeCost", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryOptionInstrTradeCostField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryOptionInstrTradeCost", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryOptionInstrTradeCost(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryOrder(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200218

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryOrder(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryOrderField *arg2 = (CThostFtdcQryOrderField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryOrderField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryOrderField *","ReqQryOrder", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryOrderField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryOrder", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryOrder(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryParkedOrder(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201658

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryParkedOrder(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryParkedOrderField *arg2 = (CThostFtdcQryParkedOrderField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryParkedOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryParkedOrderField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryParkedOrderField *","ReqQryParkedOrder", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryParkedOrderField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryParkedOrder", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryParkedOrder(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryParkedOrderAction(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201698

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryParkedOrderAction(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryParkedOrderActionField *arg2 = (CThostFtdcQryParkedOrderActionField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryParkedOrderAction", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryParkedOrderActionField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryParkedOrderActionField *","ReqQryParkedOrderAction", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryParkedOrderActionField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryParkedOrderAction", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryParkedOrderAction(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryProduct(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200578

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryProduct(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryProductField *arg2 = (CThostFtdcQryProductField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryProduct", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryProductField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryProductField *","ReqQryProduct", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryProductField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryProduct", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryProduct(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryProductExchRate(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201218

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryProductExchRate(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryProductExchRateField *arg2 = (CThostFtdcQryProductExchRateField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryProductExchRate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryProductExchRateField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryProductExchRateField *","ReqQryProductExchRate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryProductExchRateField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryProductExchRate", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryProductExchRate(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryQuote(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201418

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryQuote(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryQuoteField *arg2 = (CThostFtdcQryQuoteField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryQuote", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryQuoteField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryQuoteField *","ReqQryQuote", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryQuoteField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryQuote", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryQuote(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQrySecAgentACIDMap(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201178

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQrySecAgentACIDMap(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQrySecAgentACIDMapField *arg2 = (CThostFtdcQrySecAgentACIDMapField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQrySecAgentACIDMap", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQrySecAgentACIDMapField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQrySecAgentACIDMapField *","ReqQrySecAgentACIDMap", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQrySecAgentACIDMapField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQrySecAgentACIDMap", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQrySecAgentACIDMap(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQrySettlementInfo(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200698

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQrySettlementInfo(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQrySettlementInfoField *arg2 = (CThostFtdcQrySettlementInfoField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQrySettlementInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQrySettlementInfoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQrySettlementInfoField *","ReqQrySettlementInfo", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQrySettlementInfoField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQrySettlementInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQrySettlementInfo(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQrySettlementInfoConfirm(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200858

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQrySettlementInfoConfirm(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQrySettlementInfoConfirmField *arg2 = (CThostFtdcQrySettlementInfoConfirmField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQrySettlementInfoConfirm", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQrySettlementInfoConfirmField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQrySettlementInfoConfirmField *","ReqQrySettlementInfoConfirm", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQrySettlementInfoConfirmField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQrySettlementInfoConfirm", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQrySettlementInfoConfirm(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryTrade(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200258

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryTrade(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryTradeField *arg2 = (CThostFtdcQryTradeField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryTrade", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryTradeField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryTradeField *","ReqQryTrade", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryTradeField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryTrade", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryTrade(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryTradingAccount(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200338

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryTradingAccount(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryTradingAccountField *arg2 = (CThostFtdcQryTradingAccountField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryTradingAccount", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryTradingAccountField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryTradingAccountField *","ReqQryTradingAccount", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryTradingAccountField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryTradingAccount", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryTradingAccount(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryTradingCode(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200418

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryTradingCode(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryTradingCodeField *arg2 = (CThostFtdcQryTradingCodeField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryTradingCode", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryTradingCodeField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryTradingCodeField *","ReqQryTradingCode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryTradingCodeField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryTradingCode", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryTradingCode(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryTradingNotice(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201738

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryTradingNotice(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryTradingNoticeField *arg2 = (CThostFtdcQryTradingNoticeField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryTradingNotice", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryTradingNoticeField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryTradingNoticeField *","ReqQryTradingNotice", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryTradingNoticeField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryTradingNotice", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryTradingNotice(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryTransferBank(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200738

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryTransferBank(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryTransferBankField *arg2 = (CThostFtdcQryTransferBankField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryTransferBank", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryTransferBankField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryTransferBankField *","ReqQryTransferBank", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryTransferBankField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryTransferBank", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryTransferBank(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQryTransferSerial(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201538

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQryTransferSerial(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQryTransferSerialField *arg2 = (CThostFtdcQryTransferSerialField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQryTransferSerial", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQryTransferSerialField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQryTransferSerialField *","ReqQryTransferSerial", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQryTransferSerialField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQryTransferSerial", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQryTransferSerial(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQueryBankAccountMoneyByFuture(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201978

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQueryBankAccountMoneyByFuture(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcReqQueryAccountField *arg2 = (CThostFtdcReqQueryAccountField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQueryBankAccountMoneyByFuture", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcReqQueryAccountField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcReqQueryAccountField *","ReqQueryBankAccountMoneyByFuture", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcReqQueryAccountField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQueryBankAccountMoneyByFuture", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQueryBankAccountMoneyByFuture(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQueryCFMMCTradingAccountToken(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 201858

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQueryCFMMCTradingAccountToken(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQueryCFMMCTradingAccountTokenField *arg2 = (CThostFtdcQueryCFMMCTradingAccountTokenField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQueryCFMMCTradingAccountToken", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQueryCFMMCTradingAccountTokenField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQueryCFMMCTradingAccountTokenField *","ReqQueryCFMMCTradingAccountToken", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQueryCFMMCTradingAccountTokenField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQueryCFMMCTradingAccountToken", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQueryCFMMCTradingAccountToken(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQueryMaxOrderVolume(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199818

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQueryMaxOrderVolume(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcQueryMaxOrderVolumeField *arg2 = (CThostFtdcQueryMaxOrderVolumeField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQueryMaxOrderVolume", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcQueryMaxOrderVolumeField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcQueryMaxOrderVolumeField *","ReqQueryMaxOrderVolume", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcQueryMaxOrderVolumeField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQueryMaxOrderVolume", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQueryMaxOrderVolume(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQuoteAction(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200138

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQuoteAction(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcInputQuoteActionField *arg2 = (CThostFtdcInputQuoteActionField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQuoteAction", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcInputQuoteActionField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcInputQuoteActionField *","ReqQuoteAction", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcInputQuoteActionField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQuoteAction", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQuoteAction(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqQuoteInsert(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 200098

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqQuoteInsert(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcInputQuoteField *arg2 = (CThostFtdcInputQuoteField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqQuoteInsert", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcInputQuoteField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcInputQuoteField *","ReqQuoteInsert", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcInputQuoteField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqQuoteInsert", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqQuoteInsert(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqRemoveParkedOrder(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199898

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqRemoveParkedOrder(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcRemoveParkedOrderField *arg2 = (CThostFtdcRemoveParkedOrderField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqRemoveParkedOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcRemoveParkedOrderField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcRemoveParkedOrderField *","ReqRemoveParkedOrder", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcRemoveParkedOrderField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqRemoveParkedOrder", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqRemoveParkedOrder(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqRemoveParkedOrderAction(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199938

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqRemoveParkedOrderAction(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcRemoveParkedOrderActionField *arg2 = (CThostFtdcRemoveParkedOrderActionField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqRemoveParkedOrderAction", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcRemoveParkedOrderActionField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcRemoveParkedOrderActionField *","ReqRemoveParkedOrderAction", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcRemoveParkedOrderActionField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqRemoveParkedOrderAction", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqRemoveParkedOrderAction(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqSettlementInfoConfirm(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199858

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqSettlementInfoConfirm(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcSettlementInfoConfirmField *arg2 = (CThostFtdcSettlementInfoConfirmField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqSettlementInfoConfirm", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcSettlementInfoConfirmField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcSettlementInfoConfirmField *","ReqSettlementInfoConfirm", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcSettlementInfoConfirmField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqSettlementInfoConfirm", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqSettlementInfoConfirm(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqTradingAccountPasswordUpdate(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199618

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqTradingAccountPasswordUpdate(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcTradingAccountPasswordUpdateField *arg2 = (CThostFtdcTradingAccountPasswordUpdateField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqTradingAccountPasswordUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcTradingAccountPasswordUpdateField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcTradingAccountPasswordUpdateField *","ReqTradingAccountPasswordUpdate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcTradingAccountPasswordUpdateField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqTradingAccountPasswordUpdate", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqTradingAccountPasswordUpdate(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqUserLogin(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199498

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqUserLogin(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcReqUserLoginField *arg2 = (CThostFtdcReqUserLoginField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqUserLogin", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcReqUserLoginField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcReqUserLoginField *","ReqUserLogin", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcReqUserLoginField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqUserLogin", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqUserLogin(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqUserLogout(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199538

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqUserLogout(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcUserLogoutField *arg2 = (CThostFtdcUserLogoutField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqUserLogout", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcUserLogoutField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcUserLogoutField *","ReqUserLogout", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcUserLogoutField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqUserLogout", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqUserLogout(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ReqUserPasswordUpdate(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199578

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_ReqUserPasswordUpdate(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  CThostFtdcUserPasswordUpdateField *arg2 = (CThostFtdcUserPasswordUpdateField *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","ReqUserPasswordUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_CThostFtdcUserPasswordUpdateField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CThostFtdcUserPasswordUpdateField *","ReqUserPasswordUpdate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< CThostFtdcUserPasswordUpdateField * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","ReqUserPasswordUpdate", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->ReqUserPasswordUpdate(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#SubscribePrivateTopic(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199400

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_SubscribePrivateTopic(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  THOST_TE_RESUME_TYPE arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","SubscribePrivateTopic", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "THOST_TE_RESUME_TYPE","SubscribePrivateTopic", 2, argv[0] ));
  } 
  arg2 = static_cast< THOST_TE_RESUME_TYPE >(val2);
  (arg1)->SubscribePrivateTopic(arg2);
  return Qnil;
fail:
  return Qnil;
}

#SubscribePublicTopic(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 199429

SWIGINTERN VALUE
_wrap_CThostFtdcTraderApi_SubscribePublicTopic(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTraderApi *arg1 = (CThostFtdcTraderApi *) 0 ;
  THOST_TE_RESUME_TYPE arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_CThostFtdcTraderApi, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTraderApi *","SubscribePublicTopic", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTraderApi * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "THOST_TE_RESUME_TYPE","SubscribePublicTopic", 2, argv[0] ));
  } 
  arg2 = static_cast< THOST_TE_RESUME_TYPE >(val2);
  (arg1)->SubscribePublicTopic(arg2);
  return Qnil;
fail:
  return Qnil;
}

Class: Ctp::CThostFtdcTraderApi

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.CreateFtdcTraderApi(*args, self) ⇒ Object

.GetApiVersion(*args) ⇒ Object

Instance Method Details

#GetTradingDay(*args) ⇒ Object

#Init(*args) ⇒ Object

#Join(*args) ⇒ Object

#RegisterFensUserInfo(*args) ⇒ Object

#RegisterFront(*args) ⇒ Object

#RegisterNameServer(*args) ⇒ Object

#RegisterSpi(*args) ⇒ Object

#Release(*args) ⇒ Object

#ReqAuthenticate(*args) ⇒ Object

#ReqCombActionInsert(*args) ⇒ Object

#ReqExecOrderAction(*args) ⇒ Object

#ReqExecOrderInsert(*args) ⇒ Object

#ReqForQuoteInsert(*args) ⇒ Object

#ReqFromBankToFutureByFuture(*args) ⇒ Object

#ReqFromFutureToBankByFuture(*args) ⇒ Object

#ReqOrderAction(*args) ⇒ Object

#ReqOrderInsert(*args) ⇒ Object

#ReqParkedOrderAction(*args) ⇒ Object

#ReqParkedOrderInsert(*args) ⇒ Object

#ReqQryAccountregister(*args) ⇒ Object

#ReqQryBrokerTradingAlgos(*args) ⇒ Object

#ReqQryBrokerTradingParams(*args) ⇒ Object

#ReqQryCFMMCTradingAccountKey(*args) ⇒ Object

#ReqQryCombAction(*args) ⇒ Object

#ReqQryCombInstrumentGuard(*args) ⇒ Object

#ReqQryContractBank(*args) ⇒ Object

#ReqQryDepthMarketData(*args) ⇒ Object

#ReqQryEWarrantOffset(*args) ⇒ Object

#ReqQryExchange(*args) ⇒ Object

#ReqQryExchangeMarginRate(*args) ⇒ Object

#ReqQryExchangeMarginRateAdjust(*args) ⇒ Object

#ReqQryExchangeRate(*args) ⇒ Object

#ReqQryExecOrder(*args) ⇒ Object

#ReqQryForQuote(*args) ⇒ Object

#ReqQryInstrument(*args) ⇒ Object

#ReqQryInstrumentCommissionRate(*args) ⇒ Object

#ReqQryInstrumentMarginRate(*args) ⇒ Object

#ReqQryInvestor(*args) ⇒ Object

#ReqQryInvestorPosition(*args) ⇒ Object

#ReqQryInvestorPositionCombineDetail(*args) ⇒ Object

#ReqQryInvestorPositionDetail(*args) ⇒ Object

#ReqQryInvestorProductGroupMargin(*args) ⇒ Object

#ReqQryNotice(*args) ⇒ Object

#ReqQryOptionInstrCommRate(*args) ⇒ Object

#ReqQryOptionInstrTradeCost(*args) ⇒ Object

#ReqQryOrder(*args) ⇒ Object

#ReqQryParkedOrder(*args) ⇒ Object

#ReqQryParkedOrderAction(*args) ⇒ Object

#ReqQryProduct(*args) ⇒ Object

#ReqQryProductExchRate(*args) ⇒ Object

#ReqQryQuote(*args) ⇒ Object

#ReqQrySecAgentACIDMap(*args) ⇒ Object

#ReqQrySettlementInfo(*args) ⇒ Object

#ReqQrySettlementInfoConfirm(*args) ⇒ Object

#ReqQryTrade(*args) ⇒ Object

#ReqQryTradingAccount(*args) ⇒ Object

#ReqQryTradingCode(*args) ⇒ Object

#ReqQryTradingNotice(*args) ⇒ Object

#ReqQryTransferBank(*args) ⇒ Object

#ReqQryTransferSerial(*args) ⇒ Object

#ReqQueryBankAccountMoneyByFuture(*args) ⇒ Object

#ReqQueryCFMMCTradingAccountToken(*args) ⇒ Object

#ReqQueryMaxOrderVolume(*args) ⇒ Object

#ReqQuoteAction(*args) ⇒ Object

#ReqQuoteInsert(*args) ⇒ Object

#ReqRemoveParkedOrder(*args) ⇒ Object

#ReqRemoveParkedOrderAction(*args) ⇒ Object

#ReqSettlementInfoConfirm(*args) ⇒ Object

#ReqTradingAccountPasswordUpdate(*args) ⇒ Object

#ReqUserLogin(*args) ⇒ Object

#ReqUserLogout(*args) ⇒ Object

#ReqUserPasswordUpdate(*args) ⇒ Object

#SubscribePrivateTopic(*args) ⇒ Object

.CreateFtdcTraderApi(*args, self) ⇒ `Object`

.GetApiVersion(*args) ⇒ `Object`

#GetTradingDay(*args) ⇒ `Object`

#Init(*args) ⇒ `Object`

#Join(*args) ⇒ `Object`

#RegisterFensUserInfo(*args) ⇒ `Object`

#RegisterFront(*args) ⇒ `Object`

#RegisterNameServer(*args) ⇒ `Object`

#RegisterSpi(*args) ⇒ `Object`

#Release(*args) ⇒ `Object`

#ReqAuthenticate(*args) ⇒ `Object`

#ReqCombActionInsert(*args) ⇒ `Object`

#ReqExecOrderAction(*args) ⇒ `Object`

#ReqExecOrderInsert(*args) ⇒ `Object`

#ReqForQuoteInsert(*args) ⇒ `Object`

#ReqFromBankToFutureByFuture(*args) ⇒ `Object`

#ReqFromFutureToBankByFuture(*args) ⇒ `Object`

#ReqOrderAction(*args) ⇒ `Object`

#ReqOrderInsert(*args) ⇒ `Object`

#ReqParkedOrderAction(*args) ⇒ `Object`

#ReqParkedOrderInsert(*args) ⇒ `Object`

#ReqQryAccountregister(*args) ⇒ `Object`

#ReqQryBrokerTradingAlgos(*args) ⇒ `Object`

#ReqQryBrokerTradingParams(*args) ⇒ `Object`

#ReqQryCFMMCTradingAccountKey(*args) ⇒ `Object`

#ReqQryCombAction(*args) ⇒ `Object`

#ReqQryCombInstrumentGuard(*args) ⇒ `Object`

#ReqQryContractBank(*args) ⇒ `Object`

#ReqQryDepthMarketData(*args) ⇒ `Object`

#ReqQryEWarrantOffset(*args) ⇒ `Object`

#ReqQryExchange(*args) ⇒ `Object`

#ReqQryExchangeMarginRate(*args) ⇒ `Object`

#ReqQryExchangeMarginRateAdjust(*args) ⇒ `Object`

#ReqQryExchangeRate(*args) ⇒ `Object`

#ReqQryExecOrder(*args) ⇒ `Object`

#ReqQryForQuote(*args) ⇒ `Object`

#ReqQryInstrument(*args) ⇒ `Object`

#ReqQryInstrumentCommissionRate(*args) ⇒ `Object`

#ReqQryInstrumentMarginRate(*args) ⇒ `Object`

#ReqQryInvestor(*args) ⇒ `Object`

#ReqQryInvestorPosition(*args) ⇒ `Object`

#ReqQryInvestorPositionCombineDetail(*args) ⇒ `Object`

#ReqQryInvestorPositionDetail(*args) ⇒ `Object`

#ReqQryInvestorProductGroupMargin(*args) ⇒ `Object`

#ReqQryNotice(*args) ⇒ `Object`

#ReqQryOptionInstrCommRate(*args) ⇒ `Object`

#ReqQryOptionInstrTradeCost(*args) ⇒ `Object`

#ReqQryOrder(*args) ⇒ `Object`

#ReqQryParkedOrder(*args) ⇒ `Object`

#ReqQryParkedOrderAction(*args) ⇒ `Object`

#ReqQryProduct(*args) ⇒ `Object`

#ReqQryProductExchRate(*args) ⇒ `Object`

#ReqQryQuote(*args) ⇒ `Object`

#ReqQrySecAgentACIDMap(*args) ⇒ `Object`

#ReqQrySettlementInfo(*args) ⇒ `Object`

#ReqQrySettlementInfoConfirm(*args) ⇒ `Object`

#ReqQryTrade(*args) ⇒ `Object`

#ReqQryTradingAccount(*args) ⇒ `Object`

#ReqQryTradingCode(*args) ⇒ `Object`

#ReqQryTradingNotice(*args) ⇒ `Object`

#ReqQryTransferBank(*args) ⇒ `Object`

#ReqQryTransferSerial(*args) ⇒ `Object`

#ReqQueryBankAccountMoneyByFuture(*args) ⇒ `Object`

#ReqQueryCFMMCTradingAccountToken(*args) ⇒ `Object`

#ReqQueryMaxOrderVolume(*args) ⇒ `Object`

#ReqQuoteAction(*args) ⇒ `Object`

#ReqQuoteInsert(*args) ⇒ `Object`

#ReqRemoveParkedOrder(*args) ⇒ `Object`

#ReqRemoveParkedOrderAction(*args) ⇒ `Object`

#ReqSettlementInfoConfirm(*args) ⇒ `Object`

#ReqTradingAccountPasswordUpdate(*args) ⇒ `Object`

#ReqUserLogin(*args) ⇒ `Object`

#ReqUserLogout(*args) ⇒ `Object`

#ReqUserPasswordUpdate(*args) ⇒ `Object`

#SubscribePrivateTopic(*args) ⇒ `Object`

#SubscribePublicTopic(*args) ⇒ `Object`