Class: Ctp::CThostFtdcReqCancelAccountField

Inherits:
Object
  • Object
show all
Defined in:
ext/ctp/ctp.cxx

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



139674
139675
139676
139677
139678
139679
139680
139681
139682
139683
139684
139685
139686
139687
 
# File 'ext/ctp/ctp.cxx', line 139674

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

Instance Method Details

#AccountID(*args) ⇒ Object 



138725
138726
138727
138728
138729
138730
138731
138732
138733
138734
138735
138736
138737
138738
138739
138740
138741
138742
138743
138744
138745
138746
138747
138748
138749
138750
138751
138752
 
# File 'ext/ctp/ctp.cxx', line 138725

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



138695
138696
138697
138698
138699
138700
138701
138702
138703
138704
138705
138706
138707
138708
138709
138710
138711
138712
138713
138714
138715
138716
138717
138718
138719
138720
138721
138722
 
# File 'ext/ctp/ctp.cxx', line 138695

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



138192
138193
138194
138195
138196
138197
138198
138199
138200
138201
138202
138203
138204
138205
138206
138207
138208
138209
138210
138211
138212
138213
138214
138215
138216
138217
138218
138219
 
# File 'ext/ctp/ctp.cxx', line 138192

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



138162
138163
138164
138165
138166
138167
138168
138169
138170
138171
138172
138173
138174
138175
138176
138177
138178
138179
138180
138181
138182
138183
138184
138185
138186
138187
138188
138189
 
# File 'ext/ctp/ctp.cxx', line 138162

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



138605
138606
138607
138608
138609
138610
138611
138612
138613
138614
138615
138616
138617
138618
138619
138620
138621
138622
138623
138624
138625
138626
138627
138628
138629
138630
138631
138632
 
# File 'ext/ctp/ctp.cxx', line 138605

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



138575
138576
138577
138578
138579
138580
138581
138582
138583
138584
138585
138586
138587
138588
138589
138590
138591
138592
138593
138594
138595
138596
138597
138598
138599
138600
138601
138602
 
# File 'ext/ctp/ctp.cxx', line 138575

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



139123
139124
139125
139126
139127
139128
139129
139130
139131
139132
139133
139134
139135
139136
139137
139138
139139
139140
139141
139142
139143
139144
 
# File 'ext/ctp/ctp.cxx', line 139123

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

#BankAccType=(*args) ⇒ Object 



139094
139095
139096
139097
139098
139099
139100
139101
139102
139103
139104
139105
139106
139107
139108
139109
139110
139111
139112
139113
139114
139115
139116
139117
139118
139119
139120
 
# File 'ext/ctp/ctp.cxx', line 139094

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



137274
137275
137276
137277
137278
137279
137280
137281
137282
137283
137284
137285
137286
137287
137288
137289
137290
137291
137292
137293
137294
137295
137296
137297
137298
137299
137300
137301
 
# File 'ext/ctp/ctp.cxx', line 137274

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



137244
137245
137246
137247
137248
137249
137250
137251
137252
137253
137254
137255
137256
137257
137258
137259
137260
137261
137262
137263
137264
137265
137266
137267
137268
137269
137270
137271
 
# File 'ext/ctp/ctp.cxx', line 137244

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



137214
137215
137216
137217
137218
137219
137220
137221
137222
137223
137224
137225
137226
137227
137228
137229
137230
137231
137232
137233
137234
137235
137236
137237
137238
137239
137240
137241
 
# File 'ext/ctp/ctp.cxx', line 137214

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



137184
137185
137186
137187
137188
137189
137190
137191
137192
137193
137194
137195
137196
137197
137198
137199
137200
137201
137202
137203
137204
137205
137206
137207
137208
137209
137210
137211
 
# File 'ext/ctp/ctp.cxx', line 137184

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



138665
138666
138667
138668
138669
138670
138671
138672
138673
138674
138675
138676
138677
138678
138679
138680
138681
138682
138683
138684
138685
138686
138687
138688
138689
138690
138691
138692
 
# File 'ext/ctp/ctp.cxx', line 138665

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



138635
138636
138637
138638
138639
138640
138641
138642
138643
138644
138645
138646
138647
138648
138649
138650
138651
138652
138653
138654
138655
138656
138657
138658
138659
138660
138661
138662
 
# File 'ext/ctp/ctp.cxx', line 138635

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



139409
139410
139411
139412
139413
139414
139415
139416
139417
139418
139419
139420
139421
139422
139423
139424
139425
139426
139427
139428
139429
139430
 
# File 'ext/ctp/ctp.cxx', line 139409

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

#BankPwdFlag=(*args) ⇒ Object 



139380
139381
139382
139383
139384
139385
139386
139387
139388
139389
139390
139391
139392
139393
139394
139395
139396
139397
139398
139399
139400
139401
139402
139403
139404
139405
139406
 
# File 'ext/ctp/ctp.cxx', line 139380

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

#BankSecuAcc(*args) ⇒ Object 



139350
139351
139352
139353
139354
139355
139356
139357
139358
139359
139360
139361
139362
139363
139364
139365
139366
139367
139368
139369
139370
139371
139372
139373
139374
139375
139376
139377
 
# File 'ext/ctp/ctp.cxx', line 139350

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

#BankSecuAcc=(*args) ⇒ Object 



139320
139321
139322
139323
139324
139325
139326
139327
139328
139329
139330
139331
139332
139333
139334
139335
139336
139337
139338
139339
139340
139341
139342
139343
139344
139345
139346
139347
 
# File 'ext/ctp/ctp.cxx', line 139320

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

#BankSecuAccType(*args) ⇒ Object 



139236
139237
139238
139239
139240
139241
139242
139243
139244
139245
139246
139247
139248
139249
139250
139251
139252
139253
139254
139255
139256
139257
 
# File 'ext/ctp/ctp.cxx', line 139236

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

#BankSecuAccType=(*args) ⇒ Object 



139207
139208
139209
139210
139211
139212
139213
139214
139215
139216
139217
139218
139219
139220
139221
139222
139223
139224
139225
139226
139227
139228
139229
139230
139231
139232
139233
 
# File 'ext/ctp/ctp.cxx', line 139207

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

#BankSerial(*args) ⇒ Object 



137574
137575
137576
137577
137578
137579
137580
137581
137582
137583
137584
137585
137586
137587
137588
137589
137590
137591
137592
137593
137594
137595
137596
137597
137598
137599
137600
137601
 
# File 'ext/ctp/ctp.cxx', line 137574

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



137544
137545
137546
137547
137548
137549
137550
137551
137552
137553
137554
137555
137556
137557
137558
137559
137560
137561
137562
137563
137564
137565
137566
137567
137568
137569
137570
137571
 
# File 'ext/ctp/ctp.cxx', line 137544

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



137394
137395
137396
137397
137398
137399
137400
137401
137402
137403
137404
137405
137406
137407
137408
137409
137410
137411
137412
137413
137414
137415
137416
137417
137418
137419
137420
137421
 
# File 'ext/ctp/ctp.cxx', line 137394

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



137364
137365
137366
137367
137368
137369
137370
137371
137372
137373
137374
137375
137376
137377
137378
137379
137380
137381
137382
137383
137384
137385
137386
137387
137388
137389
137390
137391
 
# File 'ext/ctp/ctp.cxx', line 137364

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



137334
137335
137336
137337
137338
137339
137340
137341
137342
137343
137344
137345
137346
137347
137348
137349
137350
137351
137352
137353
137354
137355
137356
137357
137358
137359
137360
137361
 
# File 'ext/ctp/ctp.cxx', line 137334

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



137304
137305
137306
137307
137308
137309
137310
137311
137312
137313
137314
137315
137316
137317
137318
137319
137320
137321
137322
137323
137324
137325
137326
137327
137328
137329
137330
137331
 
# File 'ext/ctp/ctp.cxx', line 137304

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



139290
139291
139292
139293
139294
139295
139296
139297
139298
139299
139300
139301
139302
139303
139304
139305
139306
139307
139308
139309
139310
139311
139312
139313
139314
139315
139316
139317
 
# File 'ext/ctp/ctp.cxx', line 139290

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



139260
139261
139262
139263
139264
139265
139266
139267
139268
139269
139270
139271
139272
139273
139274
139275
139276
139277
139278
139279
139280
139281
139282
139283
139284
139285
139286
139287
 
# File 'ext/ctp/ctp.cxx', line 139260

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

#CashExchangeCode(*args) ⇒ Object 



139010
139011
139012
139013
139014
139015
139016
139017
139018
139019
139020
139021
139022
139023
139024
139025
139026
139027
139028
139029
139030
139031
 
# File 'ext/ctp/ctp.cxx', line 139010

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

#CashExchangeCode=(*args) ⇒ Object 



138981
138982
138983
138984
138985
138986
138987
138988
138989
138990
138991
138992
138993
138994
138995
138996
138997
138998
138999
139000
139001
139002
139003
139004
139005
139006
139007
 
# File 'ext/ctp/ctp.cxx', line 138981

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

#CountryCode(*args) ⇒ Object 



138079
138080
138081
138082
138083
138084
138085
138086
138087
138088
138089
138090
138091
138092
138093
138094
138095
138096
138097
138098
138099
138100
138101
138102
138103
138104
138105
138106
 
# File 'ext/ctp/ctp.cxx', line 138079

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



138049
138050
138051
138052
138053
138054
138055
138056
138057
138058
138059
138060
138061
138062
138063
138064
138065
138066
138067
138068
138069
138070
138071
138072
138073
138074
138075
138076
 
# File 'ext/ctp/ctp.cxx', line 138049

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



138951
138952
138953
138954
138955
138956
138957
138958
138959
138960
138961
138962
138963
138964
138965
138966
138967
138968
138969
138970
138971
138972
138973
138974
138975
138976
138977
138978
 
# File 'ext/ctp/ctp.cxx', line 138951

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



138921
138922
138923
138924
138925
138926
138927
138928
138929
138930
138931
138932
138933
138934
138935
138936
138937
138938
138939
138940
138941
138942
138943
138944
138945
138946
138947
138948
 
# File 'ext/ctp/ctp.cxx', line 138921

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



137853
137854
137855
137856
137857
137858
137859
137860
137861
137862
137863
137864
137865
137866
137867
137868
137869
137870
137871
137872
137873
137874
137875
137876
137877
137878
137879
137880
 
# File 'ext/ctp/ctp.cxx', line 137853

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



137823
137824
137825
137826
137827
137828
137829
137830
137831
137832
137833
137834
137835
137836
137837
137838
137839
137840
137841
137842
137843
137844
137845
137846
137847
137848
137849
137850
 
# File 'ext/ctp/ctp.cxx', line 137823

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



138138
138139
138140
138141
138142
138143
138144
138145
138146
138147
138148
138149
138150
138151
138152
138153
138154
138155
138156
138157
138158
138159
 
# File 'ext/ctp/ctp.cxx', line 138138

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

#CustType=(*args) ⇒ Object 



138109
138110
138111
138112
138113
138114
138115
138116
138117
138118
138119
138120
138121
138122
138123
138124
138125
138126
138127
138128
138129
138130
138131
138132
138133
138134
138135
 
# File 'ext/ctp/ctp.cxx', line 138109

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

#DeviceID(*args) ⇒ Object 



139177
139178
139179
139180
139181
139182
139183
139184
139185
139186
139187
139188
139189
139190
139191
139192
139193
139194
139195
139196
139197
139198
139199
139200
139201
139202
139203
139204
 
# File 'ext/ctp/ctp.cxx', line 139177

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

#DeviceID=(*args) ⇒ Object 



139147
139148
139149
139150
139151
139152
139153
139154
139155
139156
139157
139158
139159
139160
139161
139162
139163
139164
139165
139166
139167
139168
139169
139170
139171
139172
139173
139174
 
# File 'ext/ctp/ctp.cxx', line 139147

SWIGINTERN VALUE
_wrap_CThostFtdcReqCancelAccountField_DeviceID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqCancelAccountField *arg1 = (CThostFtdcReqCancelAccountField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[3] ;
  int res2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcReqCancelAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqCancelAccountField *","DeviceID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqCancelAccountField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 3);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [3]","DeviceID", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->DeviceID,arg2,3*sizeof(char));
  else memset(arg1->DeviceID,0,3*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#Digest(*args) ⇒ Object 



139064
139065
139066
139067
139068
139069
139070
139071
139072
139073
139074
139075
139076
139077
139078
139079
139080
139081
139082
139083
139084
139085
139086
139087
139088
139089
139090
139091
 
# File 'ext/ctp/ctp.cxx', line 139064

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



139034
139035
139036
139037
139038
139039
139040
139041
139042
139043
139044
139045
139046
139047
139048
139049
139050
139051
139052
139053
139054
139055
139056
139057
139058
139059
139060
139061
 
# File 'ext/ctp/ctp.cxx', line 139034

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



138492
138493
138494
138495
138496
138497
138498
138499
138500
138501
138502
138503
138504
138505
138506
138507
138508
138509
138510
138511
138512
138513
138514
138515
138516
138517
138518
138519
 
# File 'ext/ctp/ctp.cxx', line 138492

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



138462
138463
138464
138465
138466
138467
138468
138469
138470
138471
138472
138473
138474
138475
138476
138477
138478
138479
138480
138481
138482
138483
138484
138485
138486
138487
138488
138489
 
# File 'ext/ctp/ctp.cxx', line 138462

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

#Fax(*args) ⇒ Object 



138432
138433
138434
138435
138436
138437
138438
138439
138440
138441
138442
138443
138444
138445
138446
138447
138448
138449
138450
138451
138452
138453
138454
138455
138456
138457
138458
138459
 
# File 'ext/ctp/ctp.cxx', line 138432

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



138402
138403
138404
138405
138406
138407
138408
138409
138410
138411
138412
138413
138414
138415
138416
138417
138418
138419
138420
138421
138422
138423
138424
138425
138426
138427
138428
138429
 
# File 'ext/ctp/ctp.cxx', line 138402

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



138025
138026
138027
138028
138029
138030
138031
138032
138033
138034
138035
138036
138037
138038
138039
138040
138041
138042
138043
138044
138045
138046
 
# File 'ext/ctp/ctp.cxx', line 138025

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

#Gender=(*args) ⇒ Object 



137996
137997
137998
137999
138000
138001
138002
138003
138004
138005
138006
138007
138008
138009
138010
138011
138012
138013
138014
138015
138016
138017
138018
138019
138020
138021
138022
 
# File 'ext/ctp/ctp.cxx', line 137996

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



137912
137913
137914
137915
137916
137917
137918
137919
137920
137921
137922
137923
137924
137925
137926
137927
137928
137929
137930
137931
137932
137933
 
# File 'ext/ctp/ctp.cxx', line 137912

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

#IdCardType=(*args) ⇒ Object 



137883
137884
137885
137886
137887
137888
137889
137890
137891
137892
137893
137894
137895
137896
137897
137898
137899
137900
137901
137902
137903
137904
137905
137906
137907
137908
137909
 
# File 'ext/ctp/ctp.cxx', line 137883

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



137966
137967
137968
137969
137970
137971
137972
137973
137974
137975
137976
137977
137978
137979
137980
137981
137982
137983
137984
137985
137986
137987
137988
137989
137990
137991
137992
137993
 
# File 'ext/ctp/ctp.cxx', line 137966

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



137936
137937
137938
137939
137940
137941
137942
137943
137944
137945
137946
137947
137948
137949
137950
137951
137952
137953
137954
137955
137956
137957
137958
137959
137960
137961
137962
137963
 
# File 'ext/ctp/ctp.cxx', line 137936

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



138844
138845
138846
138847
138848
138849
138850
138851
138852
138853
138854
138855
138856
138857
138858
138859
138860
138861
138862
138863
138864
138865
 
# File 'ext/ctp/ctp.cxx', line 138844

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

#InstallID=(*args) ⇒ Object 



138815
138816
138817
138818
138819
138820
138821
138822
138823
138824
138825
138826
138827
138828
138829
138830
138831
138832
138833
138834
138835
138836
138837
138838
138839
138840
138841
 
# File 'ext/ctp/ctp.cxx', line 138815

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



137746
137747
137748
137749
137750
137751
137752
137753
137754
137755
137756
137757
137758
137759
137760
137761
137762
137763
137764
137765
137766
137767
 
# File 'ext/ctp/ctp.cxx', line 137746

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

#LastFragment=(*args) ⇒ Object 



137717
137718
137719
137720
137721
137722
137723
137724
137725
137726
137727
137728
137729
137730
137731
137732
137733
137734
137735
137736
137737
137738
137739
137740
137741
137742
137743
 
# File 'ext/ctp/ctp.cxx', line 137717

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



138372
138373
138374
138375
138376
138377
138378
138379
138380
138381
138382
138383
138384
138385
138386
138387
138388
138389
138390
138391
138392
138393
138394
138395
138396
138397
138398
138399
 
# File 'ext/ctp/ctp.cxx', line 138372

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



138342
138343
138344
138345
138346
138347
138348
138349
138350
138351
138352
138353
138354
138355
138356
138357
138358
138359
138360
138361
138362
138363
138364
138365
138366
138367
138368
138369
 
# File 'ext/ctp/ctp.cxx', line 138342

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



138551
138552
138553
138554
138555
138556
138557
138558
138559
138560
138561
138562
138563
138564
138565
138566
138567
138568
138569
138570
138571
138572
 
# File 'ext/ctp/ctp.cxx', line 138551

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

#MoneyAccountStatus=(*args) ⇒ Object 



138522
138523
138524
138525
138526
138527
138528
138529
138530
138531
138532
138533
138534
138535
138536
138537
138538
138539
138540
138541
138542
138543
138544
138545
138546
138547
138548
 
# File 'ext/ctp/ctp.cxx', line 138522

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

#OperNo(*args) ⇒ Object 



139516
139517
139518
139519
139520
139521
139522
139523
139524
139525
139526
139527
139528
139529
139530
139531
139532
139533
139534
139535
139536
139537
139538
139539
139540
139541
139542
139543
 
# File 'ext/ctp/ctp.cxx', line 139516

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

#OperNo=(*args) ⇒ Object 



139486
139487
139488
139489
139490
139491
139492
139493
139494
139495
139496
139497
139498
139499
139500
139501
139502
139503
139504
139505
139506
139507
139508
139509
139510
139511
139512
139513
 
# File 'ext/ctp/ctp.cxx', line 139486

SWIGINTERN VALUE
_wrap_CThostFtdcReqCancelAccountField_OperNo_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqCancelAccountField *arg1 = (CThostFtdcReqCancelAccountField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[17] ;
  int res2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcReqCancelAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqCancelAccountField *","OperNo", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqCancelAccountField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 17);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [17]","OperNo", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->OperNo,arg2,17*sizeof(char));
  else memset(arg1->OperNo,0,17*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#Password(*args) ⇒ Object 



138785
138786
138787
138788
138789
138790
138791
138792
138793
138794
138795
138796
138797
138798
138799
138800
138801
138802
138803
138804
138805
138806
138807
138808
138809
138810
138811
138812
 
# File 'ext/ctp/ctp.cxx', line 138785

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



138755
138756
138757
138758
138759
138760
138761
138762
138763
138764
138765
138766
138767
138768
138769
138770
138771
138772
138773
138774
138775
138776
138777
138778
138779
138780
138781
138782
 
# File 'ext/ctp/ctp.cxx', line 138755

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



137693
137694
137695
137696
137697
137698
137699
137700
137701
137702
137703
137704
137705
137706
137707
137708
137709
137710
137711
137712
137713
137714
 
# File 'ext/ctp/ctp.cxx', line 137693

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

#PlateSerial=(*args) ⇒ Object 



137664
137665
137666
137667
137668
137669
137670
137671
137672
137673
137674
137675
137676
137677
137678
137679
137680
137681
137682
137683
137684
137685
137686
137687
137688
137689
137690
 
# File 'ext/ctp/ctp.cxx', line 137664

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



139462
139463
139464
139465
139466
139467
139468
139469
139470
139471
139472
139473
139474
139475
139476
139477
139478
139479
139480
139481
139482
139483
 
# File 'ext/ctp/ctp.cxx', line 139462

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

#SecuPwdFlag=(*args) ⇒ Object 



139433
139434
139435
139436
139437
139438
139439
139440
139441
139442
139443
139444
139445
139446
139447
139448
139449
139450
139451
139452
139453
139454
139455
139456
139457
139458
139459
 
# File 'ext/ctp/ctp.cxx', line 139433

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



137799
137800
137801
137802
137803
137804
137805
137806
137807
137808
137809
137810
137811
137812
137813
137814
137815
137816
137817
137818
137819
137820
 
# File 'ext/ctp/ctp.cxx', line 137799

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

#SessionID=(*args) ⇒ Object 



137770
137771
137772
137773
137774
137775
137776
137777
137778
137779
137780
137781
137782
137783
137784
137785
137786
137787
137788
137789
137790
137791
137792
137793
137794
137795
137796
 
# File 'ext/ctp/ctp.cxx', line 137770

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



138312
138313
138314
138315
138316
138317
138318
138319
138320
138321
138322
138323
138324
138325
138326
138327
138328
138329
138330
138331
138332
138333
138334
138335
138336
138337
138338
138339
 
# File 'ext/ctp/ctp.cxx', line 138312

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



138282
138283
138284
138285
138286
138287
138288
138289
138290
138291
138292
138293
138294
138295
138296
138297
138298
138299
138300
138301
138302
138303
138304
138305
138306
138307
138308
138309
 
# File 'ext/ctp/ctp.cxx', line 138282

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



139575
139576
139577
139578
139579
139580
139581
139582
139583
139584
139585
139586
139587
139588
139589
139590
139591
139592
139593
139594
139595
139596
 
# File 'ext/ctp/ctp.cxx', line 139575

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

#TID=(*args) ⇒ Object 



139546
139547
139548
139549
139550
139551
139552
139553
139554
139555
139556
139557
139558
139559
139560
139561
139562
139563
139564
139565
139566
139567
139568
139569
139570
139571
139572
 
# File 'ext/ctp/ctp.cxx', line 139546

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



137154
137155
137156
137157
137158
137159
137160
137161
137162
137163
137164
137165
137166
137167
137168
137169
137170
137171
137172
137173
137174
137175
137176
137177
137178
137179
137180
137181
 
# File 'ext/ctp/ctp.cxx', line 137154

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



137124
137125
137126
137127
137128
137129
137130
137131
137132
137133
137134
137135
137136
137137
137138
137139
137140
137141
137142
137143
137144
137145
137146
137147
137148
137149
137150
137151
 
# File 'ext/ctp/ctp.cxx', line 137124

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



137454
137455
137456
137457
137458
137459
137460
137461
137462
137463
137464
137465
137466
137467
137468
137469
137470
137471
137472
137473
137474
137475
137476
137477
137478
137479
137480
137481
 
# File 'ext/ctp/ctp.cxx', line 137454

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



137424
137425
137426
137427
137428
137429
137430
137431
137432
137433
137434
137435
137436
137437
137438
137439
137440
137441
137442
137443
137444
137445
137446
137447
137448
137449
137450
137451
 
# File 'ext/ctp/ctp.cxx', line 137424

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



137514
137515
137516
137517
137518
137519
137520
137521
137522
137523
137524
137525
137526
137527
137528
137529
137530
137531
137532
137533
137534
137535
137536
137537
137538
137539
137540
137541
 
# File 'ext/ctp/ctp.cxx', line 137514

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



137484
137485
137486
137487
137488
137489
137490
137491
137492
137493
137494
137495
137496
137497
137498
137499
137500
137501
137502
137503
137504
137505
137506
137507
137508
137509
137510
137511
 
# File 'ext/ctp/ctp.cxx', line 137484

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



137634
137635
137636
137637
137638
137639
137640
137641
137642
137643
137644
137645
137646
137647
137648
137649
137650
137651
137652
137653
137654
137655
137656
137657
137658
137659
137660
137661
 
# File 'ext/ctp/ctp.cxx', line 137634

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



137604
137605
137606
137607
137608
137609
137610
137611
137612
137613
137614
137615
137616
137617
137618
137619
137620
137621
137622
137623
137624
137625
137626
137627
137628
137629
137630
137631
 
# File 'ext/ctp/ctp.cxx', line 137604

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

#UserID(*args) ⇒ Object 



139629
139630
139631
139632
139633
139634
139635
139636
139637
139638
139639
139640
139641
139642
139643
139644
139645
139646
139647
139648
139649
139650
139651
139652
139653
139654
139655
139656
 
# File 'ext/ctp/ctp.cxx', line 139629

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

#UserID=(*args) ⇒ Object 



139599
139600
139601
139602
139603
139604
139605
139606
139607
139608
139609
139610
139611
139612
139613
139614
139615
139616
139617
139618
139619
139620
139621
139622
139623
139624
139625
139626
 
# File 'ext/ctp/ctp.cxx', line 139599

SWIGINTERN VALUE
_wrap_CThostFtdcReqCancelAccountField_UserID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcReqCancelAccountField *arg1 = (CThostFtdcReqCancelAccountField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[16] ;
  int res2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcReqCancelAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcReqCancelAccountField *","UserID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcReqCancelAccountField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 16);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [16]","UserID", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->UserID,arg2,16*sizeof(char));
  else memset(arg1->UserID,0,16*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#VerifyCertNoFlag(*args) ⇒ Object 



138897
138898
138899
138900
138901
138902
138903
138904
138905
138906
138907
138908
138909
138910
138911
138912
138913
138914
138915
138916
138917
138918
 
# File 'ext/ctp/ctp.cxx', line 138897

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

#VerifyCertNoFlag=(*args) ⇒ Object 



138868
138869
138870
138871
138872
138873
138874
138875
138876
138877
138878
138879
138880
138881
138882
138883
138884
138885
138886
138887
138888
138889
138890
138891
138892
138893
138894
 
# File 'ext/ctp/ctp.cxx', line 138868

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



138252
138253
138254
138255
138256
138257
138258
138259
138260
138261
138262
138263
138264
138265
138266
138267
138268
138269
138270
138271
138272
138273
138274
138275
138276
138277
138278
138279
 
# File 'ext/ctp/ctp.cxx', line 138252

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



138222
138223
138224
138225
138226
138227
138228
138229
138230
138231
138232
138233
138234
138235
138236
138237
138238
138239
138240
138241
138242
138243
138244
138245
138246
138247
138248
138249
 
# File 'ext/ctp/ctp.cxx', line 138222

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