Class: Ctp::CThostFtdcChangeAccountField

Inherits:

Object

Object
Ctp::CThostFtdcChangeAccountField

Defined in:: ext/ctp/ctp.cxx

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ `Object`

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

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

Instance Method Details

#AccountID(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_AccountID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","AccountID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188374

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_AccountID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","AccountID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#Address(*args) ⇒ `Object`

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

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

#Address=(*args) ⇒ `Object`

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

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

#BankAccount(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankAccount_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankAccount", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188134

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankAccount_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankAccount", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188523

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankAccType_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankAccType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188494

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankAccType_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankAccType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 186833

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankBranchID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankBranchID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 186803

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankBranchID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankBranchID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 186773

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 186743

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188224

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankPassWord_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankPassWord", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188194

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankPassWord_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankPassWord", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188802

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankPwdFlag_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankPwdFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188773

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankPwdFlag_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankPwdFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#BankSerial(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankSerial_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankSerial", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187103

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BankSerial_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BankSerial", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 186953

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BrokerBranchID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BrokerBranchID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 186923

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BrokerBranchID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BrokerBranchID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#BrokerID(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BrokerID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BrokerID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 186863

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BrokerID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BrokerID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188743

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BrokerIDByBank_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BrokerIDByBank", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188713

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_BrokerIDByBank_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","BrokerIDByBank", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#CountryCode(*args) ⇒ `Object`

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

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

#CountryCode=(*args) ⇒ `Object`

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

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

#CurrencyID(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_CurrencyID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","CurrencyID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188653

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_CurrencyID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","CurrencyID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#CustomerName(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_CustomerName_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","CustomerName", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187382

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_CustomerName_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","CustomerName", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187697

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_CustType_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","CustType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187668

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_CustType_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","CustType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#Digest(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_Digest_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","Digest", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188932

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_Digest_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","Digest", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#EMail(*args) ⇒ `Object`

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

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

#EMail=(*args) ⇒ `Object`

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

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

#ErrorID(*args) ⇒ `Object`

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

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

#ErrorID=(*args) ⇒ `Object`

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

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

#ErrorMsg(*args) ⇒ `Object`

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

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

#ErrorMsg=(*args) ⇒ `Object`

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

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

#Fax(*args) ⇒ `Object`

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

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

#Fax=(*args) ⇒ `Object`

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

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

#Gender(*args) ⇒ `Object`

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

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

#Gender=(*args) ⇒ `Object`

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

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

#IdCardType(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_IdCardType_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","IdCardType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187442

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_IdCardType_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","IdCardType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187525

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_IdentifiedCardNo_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","IdentifiedCardNo", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187495

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_IdentifiedCardNo_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","IdentifiedCardNo", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188576

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_InstallID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","InstallID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188547

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_InstallID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","InstallID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187305

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_LastFragment_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","LastFragment", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187276

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_LastFragment_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","LastFragment", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#MobilePhone(*args) ⇒ `Object`

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

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

#MobilePhone=(*args) ⇒ `Object`

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

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

#MoneyAccountStatus(*args) ⇒ `Object`

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

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

#MoneyAccountStatus=(*args) ⇒ `Object`

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

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

#NewBankAccount(*args) ⇒ `Object`

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

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

#NewBankAccount=(*args) ⇒ `Object`

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

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

#NewBankPassWord(*args) ⇒ `Object`

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

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

#NewBankPassWord=(*args) ⇒ `Object`

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

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

#Password(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_Password_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","Password", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188434

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_Password_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","Password", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187252

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_PlateSerial_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","PlateSerial", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187223

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_PlateSerial_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","PlateSerial", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#SecuPwdFlag(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_SecuPwdFlag_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","SecuPwdFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188826

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_SecuPwdFlag_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","SecuPwdFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187358

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_SessionID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","SessionID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187329

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_SessionID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","SessionID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#Telephone(*args) ⇒ `Object`

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

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

#Telephone=(*args) ⇒ `Object`

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

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

#TID(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_TID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","TID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188879

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_TID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","TID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#TradeCode(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_TradeCode_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","TradeCode", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 186683

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_TradeCode_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","TradeCode", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187013

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_TradeDate_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","TradeDate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 186983

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_TradeDate_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","TradeDate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187073

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_TradeTime_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","TradeTime", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187043

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_TradeTime_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","TradeTime", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187193

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_TradingDay_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","TradingDay", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 187163

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_TradingDay_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","TradingDay", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#VerifyCertNoFlag(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_VerifyCertNoFlag_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","VerifyCertNoFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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 188600

SWIGINTERN VALUE
_wrap_CThostFtdcChangeAccountField_VerifyCertNoFlag_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcChangeAccountField *arg1 = (CThostFtdcChangeAccountField *) 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_CThostFtdcChangeAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcChangeAccountField *","VerifyCertNoFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcChangeAccountField * >(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;
}

#ZipCode(*args) ⇒ `Object`

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

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

#ZipCode=(*args) ⇒ `Object`

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

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

Class: Ctp::CThostFtdcChangeAccountField

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

Instance Method Details

#AccountID(*args) ⇒ Object

#AccountID=(*args) ⇒ Object

#Address(*args) ⇒ Object

#Address=(*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

#BankSerial(*args) ⇒ Object

#BankSerial=(*args) ⇒ Object

#BrokerBranchID(*args) ⇒ Object

#BrokerBranchID=(*args) ⇒ Object

#BrokerID(*args) ⇒ Object

#BrokerID=(*args) ⇒ Object

#BrokerIDByBank(*args) ⇒ Object

#BrokerIDByBank=(*args) ⇒ Object

#CountryCode(*args) ⇒ Object

#CountryCode=(*args) ⇒ Object

#CurrencyID(*args) ⇒ Object

#CurrencyID=(*args) ⇒ Object

#CustomerName(*args) ⇒ Object

#CustomerName=(*args) ⇒ Object

#CustType(*args) ⇒ Object

#CustType=(*args) ⇒ Object

#Digest(*args) ⇒ Object

#Digest=(*args) ⇒ Object

#EMail(*args) ⇒ Object

#EMail=(*args) ⇒ Object

#ErrorID(*args) ⇒ Object

#ErrorID=(*args) ⇒ Object

#ErrorMsg(*args) ⇒ Object

#ErrorMsg=(*args) ⇒ Object

#Fax(*args) ⇒ Object

#Fax=(*args) ⇒ Object

#Gender(*args) ⇒ Object

#Gender=(*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

#MobilePhone(*args) ⇒ Object

#MobilePhone=(*args) ⇒ Object

#MoneyAccountStatus(*args) ⇒ Object

#MoneyAccountStatus=(*args) ⇒ Object

#NewBankAccount(*args) ⇒ Object

#NewBankAccount=(*args) ⇒ Object

#NewBankPassWord(*args) ⇒ Object

#NewBankPassWord=(*args) ⇒ Object

#Password(*args) ⇒ Object

#Password=(*args) ⇒ Object

#PlateSerial(*args) ⇒ Object

#PlateSerial=(*args) ⇒ Object

#SecuPwdFlag(*args) ⇒ Object

#SecuPwdFlag=(*args) ⇒ Object

#SessionID(*args) ⇒ Object

#SessionID=(*args) ⇒ Object

#Telephone(*args) ⇒ Object

#Telephone=(*args) ⇒ Object

#TID(*args) ⇒ Object

#TID=(*args) ⇒ Object

#TradeCode(*args) ⇒ Object

#TradeCode=(*args) ⇒ Object

#TradeDate(*args) ⇒ Object

#initialize(*args) ⇒ `Object`

#AccountID(*args) ⇒ `Object`

#AccountID=(*args) ⇒ `Object`

#Address(*args) ⇒ `Object`

#Address=(*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`

#BankSerial(*args) ⇒ `Object`

#BankSerial=(*args) ⇒ `Object`

#BrokerBranchID(*args) ⇒ `Object`

#BrokerBranchID=(*args) ⇒ `Object`

#BrokerID(*args) ⇒ `Object`

#BrokerID=(*args) ⇒ `Object`

#BrokerIDByBank(*args) ⇒ `Object`

#BrokerIDByBank=(*args) ⇒ `Object`

#CountryCode(*args) ⇒ `Object`

#CountryCode=(*args) ⇒ `Object`

#CurrencyID(*args) ⇒ `Object`

#CurrencyID=(*args) ⇒ `Object`

#CustomerName(*args) ⇒ `Object`

#CustomerName=(*args) ⇒ `Object`

#CustType(*args) ⇒ `Object`

#CustType=(*args) ⇒ `Object`

#Digest(*args) ⇒ `Object`

#Digest=(*args) ⇒ `Object`

#EMail(*args) ⇒ `Object`

#EMail=(*args) ⇒ `Object`

#ErrorID(*args) ⇒ `Object`

#ErrorID=(*args) ⇒ `Object`

#ErrorMsg(*args) ⇒ `Object`

#ErrorMsg=(*args) ⇒ `Object`

#Fax(*args) ⇒ `Object`

#Fax=(*args) ⇒ `Object`

#Gender(*args) ⇒ `Object`

#Gender=(*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`

#MobilePhone(*args) ⇒ `Object`

#MobilePhone=(*args) ⇒ `Object`

#MoneyAccountStatus(*args) ⇒ `Object`

#MoneyAccountStatus=(*args) ⇒ `Object`

#NewBankAccount(*args) ⇒ `Object`

#NewBankAccount=(*args) ⇒ `Object`

#NewBankPassWord(*args) ⇒ `Object`

#NewBankPassWord=(*args) ⇒ `Object`

#Password(*args) ⇒ `Object`

#Password=(*args) ⇒ `Object`

#PlateSerial(*args) ⇒ `Object`

#PlateSerial=(*args) ⇒ `Object`

#SecuPwdFlag(*args) ⇒ `Object`

#SecuPwdFlag=(*args) ⇒ `Object`

#SessionID(*args) ⇒ `Object`

#SessionID=(*args) ⇒ `Object`

#Telephone(*args) ⇒ `Object`

#Telephone=(*args) ⇒ `Object`

#TID(*args) ⇒ `Object`

#TID=(*args) ⇒ `Object`

#TradeCode(*args) ⇒ `Object`

#TradeCode=(*args) ⇒ `Object`

#TradeDate(*args) ⇒ `Object`

#TradeDate=(*args) ⇒ `Object`

#TradeTime(*args) ⇒ `Object`

#TradeTime=(*args) ⇒ `Object`

#TradingDay(*args) ⇒ `Object`