Class: Ctp::CThostFtdcReqTransferField

Inherits:

Object

Object
Ctp::CThostFtdcReqTransferField

show all

Defined in:: ext/ctp/ctp.cxx

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_new_CThostFtdcReqTransferField(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ctp::CThostFtdcReqTransferField";
  CThostFtdcReqTransferField *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (CThostFtdcReqTransferField *)new CThostFtdcReqTransferField();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}

Instance Method Details

#AccountID(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_AccountID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","AccountID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->AccountID);
  {
    size_t size = SWIG_strnlen(result, 13);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#AccountID=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_AccountID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[13] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","AccountID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 13);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [13]","AccountID", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->AccountID,arg2,13*sizeof(char));
  else memset(arg1->AccountID,0,13*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#BankAccount(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankAccount_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankAccount", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->BankAccount);
  {
    size_t size = SWIG_strnlen(result, 41);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#BankAccount=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankAccount_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[41] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankAccount", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 41);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [41]","BankAccount", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->BankAccount,arg2,41*sizeof(char));
  else memset(arg1->BankAccount,0,41*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#BankAccType(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankAccType_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcBankAccTypeType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankAccType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcBankAccTypeType) ((arg1)->BankAccType);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#BankAccType=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankAccType_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcBankAccTypeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankAccType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcBankAccTypeType","BankAccType", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcBankAccTypeType >(val2);
  if (arg1) (arg1)->BankAccType = arg2;
  return Qnil;
fail:
  return Qnil;
}

#BankBranchID(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankBranchID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankBranchID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->BankBranchID);
  {
    size_t size = SWIG_strnlen(result, 5);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#BankBranchID=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankBranchID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[5] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankBranchID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 5);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [5]","BankBranchID", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->BankBranchID,arg2,5*sizeof(char));
  else memset(arg1->BankBranchID,0,5*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#BankID(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->BankID);
  {
    size_t size = SWIG_strnlen(result, 4);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#BankID=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[4] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 4);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [4]","BankID", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->BankID,arg2,4*sizeof(char));
  else memset(arg1->BankID,0,4*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#BankPassWord(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankPassWord_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankPassWord", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->BankPassWord);
  {
    size_t size = SWIG_strnlen(result, 41);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#BankPassWord=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankPassWord_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[41] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankPassWord", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 41);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [41]","BankPassWord", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->BankPassWord,arg2,41*sizeof(char));
  else memset(arg1->BankPassWord,0,41*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#BankPwdFlag(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankPwdFlag_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcPwdFlagType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankPwdFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcPwdFlagType) ((arg1)->BankPwdFlag);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#BankPwdFlag=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankPwdFlag_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcPwdFlagType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankPwdFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcPwdFlagType","BankPwdFlag", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcPwdFlagType >(val2);
  if (arg1) (arg1)->BankPwdFlag = arg2;
  return Qnil;
fail:
  return Qnil;
}

#BankSecuAcc(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankSecuAcc_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankSecuAcc", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->BankSecuAcc);
  {
    size_t size = SWIG_strnlen(result, 41);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#BankSecuAcc=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankSecuAcc_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[41] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankSecuAcc", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 41);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [41]","BankSecuAcc", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->BankSecuAcc,arg2,41*sizeof(char));
  else memset(arg1->BankSecuAcc,0,41*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#BankSecuAccType(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankSecuAccType_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcBankAccTypeType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankSecuAccType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcBankAccTypeType) ((arg1)->BankSecuAccType);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#BankSecuAccType=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankSecuAccType_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcBankAccTypeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankSecuAccType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcBankAccTypeType","BankSecuAccType", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcBankAccTypeType >(val2);
  if (arg1) (arg1)->BankSecuAccType = arg2;
  return Qnil;
fail:
  return Qnil;
}

#BankSerial(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankSerial_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankSerial", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->BankSerial);
  {
    size_t size = SWIG_strnlen(result, 13);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#BankSerial=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BankSerial_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[13] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BankSerial", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 13);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [13]","BankSerial", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->BankSerial,arg2,13*sizeof(char));
  else memset(arg1->BankSerial,0,13*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#BrokerBranchID(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BrokerBranchID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BrokerBranchID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->BrokerBranchID);
  {
    size_t size = SWIG_strnlen(result, 31);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#BrokerBranchID=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BrokerBranchID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[31] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BrokerBranchID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 31);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [31]","BrokerBranchID", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->BrokerBranchID,arg2,31*sizeof(char));
  else memset(arg1->BrokerBranchID,0,31*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#BrokerFee(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BrokerFee_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcFutureFeeType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BrokerFee", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcFutureFeeType) ((arg1)->BrokerFee);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#BrokerFee=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BrokerFee_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcFutureFeeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BrokerFee", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcFutureFeeType","BrokerFee", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcFutureFeeType >(val2);
  if (arg1) (arg1)->BrokerFee = arg2;
  return Qnil;
fail:
  return Qnil;
}

#BrokerID(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BrokerID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BrokerID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->BrokerID);
  {
    size_t size = SWIG_strnlen(result, 11);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#BrokerID=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BrokerID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[11] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BrokerID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 11);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [11]","BrokerID", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->BrokerID,arg2,11*sizeof(char));
  else memset(arg1->BrokerID,0,11*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#BrokerIDByBank(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BrokerIDByBank_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BrokerIDByBank", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->BrokerIDByBank);
  {
    size_t size = SWIG_strnlen(result, 33);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#BrokerIDByBank=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_BrokerIDByBank_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[33] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","BrokerIDByBank", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 33);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [33]","BrokerIDByBank", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->BrokerIDByBank,arg2,33*sizeof(char));
  else memset(arg1->BrokerIDByBank,0,33*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#CurrencyID(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_CurrencyID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","CurrencyID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->CurrencyID);
  {
    size_t size = SWIG_strnlen(result, 4);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#CurrencyID=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_CurrencyID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[4] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","CurrencyID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 4);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [4]","CurrencyID", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->CurrencyID,arg2,4*sizeof(char));
  else memset(arg1->CurrencyID,0,4*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#CustFee(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_CustFee_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcCustFeeType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","CustFee", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcCustFeeType) ((arg1)->CustFee);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#CustFee=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_CustFee_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcCustFeeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","CustFee", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcCustFeeType","CustFee", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcCustFeeType >(val2);
  if (arg1) (arg1)->CustFee = arg2;
  return Qnil;
fail:
  return Qnil;
}

#CustomerName(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_CustomerName_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","CustomerName", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->CustomerName);
  {
    size_t size = SWIG_strnlen(result, 51);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#CustomerName=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_CustomerName_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[51] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","CustomerName", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 51);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [51]","CustomerName", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->CustomerName,arg2,51*sizeof(char));
  else memset(arg1->CustomerName,0,51*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#CustType(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_CustType_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcCustTypeType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","CustType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcCustTypeType) ((arg1)->CustType);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#CustType=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_CustType_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcCustTypeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","CustType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcCustTypeType","CustType", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcCustTypeType >(val2);
  if (arg1) (arg1)->CustType = arg2;
  return Qnil;
fail:
  return Qnil;
}

#DeviceID(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_DeviceID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","DeviceID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->DeviceID);
  {
    size_t size = SWIG_strnlen(result, 3);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#DeviceID=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_DeviceID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[3] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","DeviceID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 3);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [3]","DeviceID", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->DeviceID,arg2,3*sizeof(char));
  else memset(arg1->DeviceID,0,3*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#Digest(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_Digest_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","Digest", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->Digest);
  {
    size_t size = SWIG_strnlen(result, 36);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#Digest=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_Digest_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[36] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","Digest", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 36);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [36]","Digest", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->Digest,arg2,36*sizeof(char));
  else memset(arg1->Digest,0,36*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#FeePayFlag(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_FeePayFlag_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcFeePayFlagType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","FeePayFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcFeePayFlagType) ((arg1)->FeePayFlag);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#FeePayFlag=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_FeePayFlag_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcFeePayFlagType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","FeePayFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcFeePayFlagType","FeePayFlag", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcFeePayFlagType >(val2);
  if (arg1) (arg1)->FeePayFlag = arg2;
  return Qnil;
fail:
  return Qnil;
}

#FutureFetchAmount(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_FutureFetchAmount_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcTradeAmountType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","FutureFetchAmount", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcTradeAmountType) ((arg1)->FutureFetchAmount);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#FutureFetchAmount=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_FutureFetchAmount_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcTradeAmountType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","FutureFetchAmount", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcTradeAmountType","FutureFetchAmount", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcTradeAmountType >(val2);
  if (arg1) (arg1)->FutureFetchAmount = arg2;
  return Qnil;
fail:
  return Qnil;
}

#FutureSerial(*args) ⇒ `Object`

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

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

#FutureSerial=(*args) ⇒ `Object`

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

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

#IdCardType(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_IdCardType_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcIdCardTypeType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","IdCardType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcIdCardTypeType) ((arg1)->IdCardType);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#IdCardType=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_IdCardType_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcIdCardTypeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","IdCardType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcIdCardTypeType","IdCardType", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcIdCardTypeType >(val2);
  if (arg1) (arg1)->IdCardType = arg2;
  return Qnil;
fail:
  return Qnil;
}

#IdentifiedCardNo(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_IdentifiedCardNo_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","IdentifiedCardNo", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->IdentifiedCardNo);
  {
    size_t size = SWIG_strnlen(result, 51);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#IdentifiedCardNo=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_IdentifiedCardNo_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[51] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","IdentifiedCardNo", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 51);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [51]","IdentifiedCardNo", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->IdentifiedCardNo,arg2,51*sizeof(char));
  else memset(arg1->IdentifiedCardNo,0,51*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#InstallID(*args) ⇒ `Object`

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

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

#InstallID=(*args) ⇒ `Object`

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

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

#LastFragment(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_LastFragment_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcLastFragmentType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","LastFragment", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcLastFragmentType) ((arg1)->LastFragment);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#LastFragment=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_LastFragment_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcLastFragmentType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","LastFragment", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcLastFragmentType","LastFragment", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcLastFragmentType >(val2);
  if (arg1) (arg1)->LastFragment = arg2;
  return Qnil;
fail:
  return Qnil;
}

#Message(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_Message_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","Message", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->Message);
  {
    size_t size = SWIG_strnlen(result, 129);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#Message=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_Message_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[129] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","Message", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 129);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [129]","Message", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->Message,arg2,129*sizeof(char));
  else memset(arg1->Message,0,129*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#OperNo(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_OperNo_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","OperNo", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->OperNo);
  {
    size_t size = SWIG_strnlen(result, 17);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#OperNo=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_OperNo_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[17] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","OperNo", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 17);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [17]","OperNo", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->OperNo,arg2,17*sizeof(char));
  else memset(arg1->OperNo,0,17*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#Password(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_Password_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","Password", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->Password);
  {
    size_t size = SWIG_strnlen(result, 41);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#Password=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_Password_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[41] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","Password", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 41);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [41]","Password", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->Password,arg2,41*sizeof(char));
  else memset(arg1->Password,0,41*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#PlateSerial(*args) ⇒ `Object`

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

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

#PlateSerial=(*args) ⇒ `Object`

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

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

#RequestID(*args) ⇒ `Object`

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

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

#RequestID=(*args) ⇒ `Object`

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

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

#SecuPwdFlag(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_SecuPwdFlag_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcPwdFlagType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","SecuPwdFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcPwdFlagType) ((arg1)->SecuPwdFlag);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#SecuPwdFlag=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_SecuPwdFlag_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcPwdFlagType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","SecuPwdFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcPwdFlagType","SecuPwdFlag", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcPwdFlagType >(val2);
  if (arg1) (arg1)->SecuPwdFlag = arg2;
  return Qnil;
fail:
  return Qnil;
}

#SessionID(*args) ⇒ `Object`

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

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

#SessionID=(*args) ⇒ `Object`

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

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

#TID(*args) ⇒ `Object`

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

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

#TID=(*args) ⇒ `Object`

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

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

#TradeAmount(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_TradeAmount_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcTradeAmountType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","TradeAmount", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcTradeAmountType) ((arg1)->TradeAmount);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#TradeAmount=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_TradeAmount_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcTradeAmountType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","TradeAmount", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcTradeAmountType","TradeAmount", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcTradeAmountType >(val2);
  if (arg1) (arg1)->TradeAmount = arg2;
  return Qnil;
fail:
  return Qnil;
}

#TradeCode(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_TradeCode_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","TradeCode", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->TradeCode);
  {
    size_t size = SWIG_strnlen(result, 7);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#TradeCode=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_TradeCode_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[7] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","TradeCode", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 7);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [7]","TradeCode", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->TradeCode,arg2,7*sizeof(char));
  else memset(arg1->TradeCode,0,7*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#TradeDate(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_TradeDate_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","TradeDate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->TradeDate);
  {
    size_t size = SWIG_strnlen(result, 9);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#TradeDate=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_TradeDate_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[9] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","TradeDate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 9);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [9]","TradeDate", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->TradeDate,arg2,9*sizeof(char));
  else memset(arg1->TradeDate,0,9*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#TradeTime(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_TradeTime_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","TradeTime", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->TradeTime);
  {
    size_t size = SWIG_strnlen(result, 9);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#TradeTime=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_TradeTime_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[9] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","TradeTime", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 9);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [9]","TradeTime", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->TradeTime,arg2,9*sizeof(char));
  else memset(arg1->TradeTime,0,9*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#TradingDay(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_TradingDay_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","TradingDay", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->TradingDay);
  {
    size_t size = SWIG_strnlen(result, 9);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#TradingDay=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_TradingDay_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[9] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","TradingDay", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 9);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [9]","TradingDay", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->TradingDay,arg2,9*sizeof(char));
  else memset(arg1->TradingDay,0,9*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#TransferStatus(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_TransferStatus_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcTransferStatusType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","TransferStatus", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcTransferStatusType) ((arg1)->TransferStatus);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#TransferStatus=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_TransferStatus_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcTransferStatusType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","TransferStatus", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcTransferStatusType","TransferStatus", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcTransferStatusType >(val2);
  if (arg1) (arg1)->TransferStatus = arg2;
  return Qnil;
fail:
  return Qnil;
}

#UserID(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_UserID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","UserID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (char *) ((arg1)->UserID);
  {
    size_t size = SWIG_strnlen(result, 16);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#UserID=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_UserID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[16] ;
  int res2 ;
  
  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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","UserID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 16);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [16]","UserID", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->UserID,arg2,16*sizeof(char));
  else memset(arg1->UserID,0,16*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#VerifyCertNoFlag(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_VerifyCertNoFlag_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcYesNoIndicatorType 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","VerifyCertNoFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  result = (TThostFtdcYesNoIndicatorType) ((arg1)->VerifyCertNoFlag);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#VerifyCertNoFlag=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcReqTransferField_VerifyCertNoFlag_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqTransferField *arg1 = (CThostFtdcReqTransferField *) 0 ;
  TThostFtdcYesNoIndicatorType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char 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_CThostFtdcReqTransferField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqTransferField *","VerifyCertNoFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqTransferField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcYesNoIndicatorType","VerifyCertNoFlag", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcYesNoIndicatorType >(val2);
  if (arg1) (arg1)->VerifyCertNoFlag = arg2;
  return Qnil;
fail:
  return Qnil;
}

Class: Ctp::CThostFtdcReqTransferField

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

Instance Method Details

#AccountID(*args) ⇒ Object

#AccountID=(*args) ⇒ Object

#BankAccount(*args) ⇒ Object

#BankAccount=(*args) ⇒ Object

#BankAccType(*args) ⇒ Object

#BankAccType=(*args) ⇒ Object

#BankBranchID(*args) ⇒ Object

#BankBranchID=(*args) ⇒ Object

#BankID(*args) ⇒ Object

#BankID=(*args) ⇒ Object

#BankPassWord(*args) ⇒ Object

#BankPassWord=(*args) ⇒ Object

#BankPwdFlag(*args) ⇒ Object

#BankPwdFlag=(*args) ⇒ Object

#BankSecuAcc(*args) ⇒ Object

#BankSecuAcc=(*args) ⇒ Object

#BankSecuAccType(*args) ⇒ Object

#BankSecuAccType=(*args) ⇒ Object

#BankSerial(*args) ⇒ Object

#BankSerial=(*args) ⇒ Object

#BrokerBranchID(*args) ⇒ Object

#BrokerBranchID=(*args) ⇒ Object

#BrokerFee(*args) ⇒ Object

#BrokerFee=(*args) ⇒ Object

#BrokerID(*args) ⇒ Object

#BrokerID=(*args) ⇒ Object

#BrokerIDByBank(*args) ⇒ Object

#BrokerIDByBank=(*args) ⇒ Object

#CurrencyID(*args) ⇒ Object

#CurrencyID=(*args) ⇒ Object

#CustFee(*args) ⇒ Object

#CustFee=(*args) ⇒ Object

#CustomerName(*args) ⇒ Object

#CustomerName=(*args) ⇒ Object

#CustType(*args) ⇒ Object

#CustType=(*args) ⇒ Object

#DeviceID(*args) ⇒ Object

#DeviceID=(*args) ⇒ Object

#Digest(*args) ⇒ Object

#Digest=(*args) ⇒ Object

#FeePayFlag(*args) ⇒ Object

#FeePayFlag=(*args) ⇒ Object

#FutureFetchAmount(*args) ⇒ Object

#FutureFetchAmount=(*args) ⇒ Object

#FutureSerial(*args) ⇒ Object

#FutureSerial=(*args) ⇒ Object

#IdCardType(*args) ⇒ Object

#IdCardType=(*args) ⇒ Object

#IdentifiedCardNo(*args) ⇒ Object

#IdentifiedCardNo=(*args) ⇒ Object

#InstallID(*args) ⇒ Object

#InstallID=(*args) ⇒ Object

#LastFragment(*args) ⇒ Object

#LastFragment=(*args) ⇒ Object

#Message(*args) ⇒ Object

#Message=(*args) ⇒ Object

#OperNo(*args) ⇒ Object

#OperNo=(*args) ⇒ Object

#Password(*args) ⇒ Object

#Password=(*args) ⇒ Object

#PlateSerial(*args) ⇒ Object

#PlateSerial=(*args) ⇒ Object

#RequestID(*args) ⇒ Object

#RequestID=(*args) ⇒ Object

#SecuPwdFlag(*args) ⇒ Object

#SecuPwdFlag=(*args) ⇒ Object

#SessionID(*args) ⇒ Object

#SessionID=(*args) ⇒ Object

#TID(*args) ⇒ Object

#TID=(*args) ⇒ Object

#TradeAmount(*args) ⇒ Object

#TradeAmount=(*args) ⇒ Object

#TradeCode(*args) ⇒ Object

#TradeCode=(*args) ⇒ Object

#TradeDate(*args) ⇒ Object

#initialize(*args) ⇒ `Object`

#AccountID(*args) ⇒ `Object`

#AccountID=(*args) ⇒ `Object`

#BankAccount(*args) ⇒ `Object`

#BankAccount=(*args) ⇒ `Object`

#BankAccType(*args) ⇒ `Object`

#BankAccType=(*args) ⇒ `Object`

#BankBranchID(*args) ⇒ `Object`

#BankBranchID=(*args) ⇒ `Object`

#BankID(*args) ⇒ `Object`

#BankID=(*args) ⇒ `Object`

#BankPassWord(*args) ⇒ `Object`

#BankPassWord=(*args) ⇒ `Object`

#BankPwdFlag(*args) ⇒ `Object`

#BankPwdFlag=(*args) ⇒ `Object`

#BankSecuAcc(*args) ⇒ `Object`

#BankSecuAcc=(*args) ⇒ `Object`

#BankSecuAccType(*args) ⇒ `Object`

#BankSecuAccType=(*args) ⇒ `Object`

#BankSerial(*args) ⇒ `Object`

#BankSerial=(*args) ⇒ `Object`

#BrokerBranchID(*args) ⇒ `Object`

#BrokerBranchID=(*args) ⇒ `Object`

#BrokerFee(*args) ⇒ `Object`

#BrokerFee=(*args) ⇒ `Object`

#BrokerID(*args) ⇒ `Object`

#BrokerID=(*args) ⇒ `Object`

#BrokerIDByBank(*args) ⇒ `Object`

#BrokerIDByBank=(*args) ⇒ `Object`

#CurrencyID(*args) ⇒ `Object`

#CurrencyID=(*args) ⇒ `Object`

#CustFee(*args) ⇒ `Object`

#CustFee=(*args) ⇒ `Object`

#CustomerName(*args) ⇒ `Object`

#CustomerName=(*args) ⇒ `Object`

#CustType(*args) ⇒ `Object`

#CustType=(*args) ⇒ `Object`

#DeviceID(*args) ⇒ `Object`

#DeviceID=(*args) ⇒ `Object`

#Digest(*args) ⇒ `Object`

#Digest=(*args) ⇒ `Object`

#FeePayFlag(*args) ⇒ `Object`

#FeePayFlag=(*args) ⇒ `Object`

#FutureFetchAmount(*args) ⇒ `Object`

#FutureFetchAmount=(*args) ⇒ `Object`

#FutureSerial(*args) ⇒ `Object`

#FutureSerial=(*args) ⇒ `Object`

#IdCardType(*args) ⇒ `Object`

#IdCardType=(*args) ⇒ `Object`

#IdentifiedCardNo(*args) ⇒ `Object`

#IdentifiedCardNo=(*args) ⇒ `Object`

#InstallID(*args) ⇒ `Object`

#InstallID=(*args) ⇒ `Object`

#LastFragment(*args) ⇒ `Object`

#LastFragment=(*args) ⇒ `Object`

#Message(*args) ⇒ `Object`

#Message=(*args) ⇒ `Object`

#OperNo(*args) ⇒ `Object`

#OperNo=(*args) ⇒ `Object`

#Password(*args) ⇒ `Object`

#Password=(*args) ⇒ `Object`

#PlateSerial(*args) ⇒ `Object`

#PlateSerial=(*args) ⇒ `Object`

#RequestID(*args) ⇒ `Object`

#RequestID=(*args) ⇒ `Object`

#SecuPwdFlag(*args) ⇒ `Object`

#SecuPwdFlag=(*args) ⇒ `Object`

#SessionID(*args) ⇒ `Object`

#SessionID=(*args) ⇒ `Object`

#TID(*args) ⇒ `Object`

#TID=(*args) ⇒ `Object`

#TradeAmount(*args) ⇒ `Object`

#TradeAmount=(*args) ⇒ `Object`

#TradeCode(*args) ⇒ `Object`

#TradeCode=(*args) ⇒ `Object`

#TradeDate(*args) ⇒ `Object`

#TradeDate=(*args) ⇒ `Object`

#TradeTime(*args) ⇒ `Object`

#TradeTime=(*args) ⇒ `Object`

#TradingDay(*args) ⇒ `Object`