Class: Ctp::CThostFtdcReqChangeAccountField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



142022
142023
142024
142025
142026
142027
142028
142029
142030
142031
142032
142033
142034
142035
 
# File 'ext/ctp/ctp.cxx', line 142022

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

Instance Method Details

#AccountID(*args) ⇒ Object 



141419
141420
141421
141422
141423
141424
141425
141426
141427
141428
141429
141430
141431
141432
141433
141434
141435
141436
141437
141438
141439
141440
141441
141442
141443
141444
141445
141446
 
# File 'ext/ctp/ctp.cxx', line 141419

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



141389
141390
141391
141392
141393
141394
141395
141396
141397
141398
141399
141400
141401
141402
141403
141404
141405
141406
141407
141408
141409
141410
141411
141412
141413
141414
141415
141416
 
# File 'ext/ctp/ctp.cxx', line 141389

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



140766
140767
140768
140769
140770
140771
140772
140773
140774
140775
140776
140777
140778
140779
140780
140781
140782
140783
140784
140785
140786
140787
140788
140789
140790
140791
140792
140793
 
# File 'ext/ctp/ctp.cxx', line 140766

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



140736
140737
140738
140739
140740
140741
140742
140743
140744
140745
140746
140747
140748
140749
140750
140751
140752
140753
140754
140755
140756
140757
140758
140759
140760
140761
140762
140763
 
# File 'ext/ctp/ctp.cxx', line 140736

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



141179
141180
141181
141182
141183
141184
141185
141186
141187
141188
141189
141190
141191
141192
141193
141194
141195
141196
141197
141198
141199
141200
141201
141202
141203
141204
141205
141206
 
# File 'ext/ctp/ctp.cxx', line 141179

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



141149
141150
141151
141152
141153
141154
141155
141156
141157
141158
141159
141160
141161
141162
141163
141164
141165
141166
141167
141168
141169
141170
141171
141172
141173
141174
141175
141176
 
# File 'ext/ctp/ctp.cxx', line 141149

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



141538
141539
141540
141541
141542
141543
141544
141545
141546
141547
141548
141549
141550
141551
141552
141553
141554
141555
141556
141557
141558
141559
 
# File 'ext/ctp/ctp.cxx', line 141538

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

#BankAccType=(*args) ⇒ Object 



141509
141510
141511
141512
141513
141514
141515
141516
141517
141518
141519
141520
141521
141522
141523
141524
141525
141526
141527
141528
141529
141530
141531
141532
141533
141534
141535
 
# File 'ext/ctp/ctp.cxx', line 141509

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



139848
139849
139850
139851
139852
139853
139854
139855
139856
139857
139858
139859
139860
139861
139862
139863
139864
139865
139866
139867
139868
139869
139870
139871
139872
139873
139874
139875
 
# File 'ext/ctp/ctp.cxx', line 139848

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



139818
139819
139820
139821
139822
139823
139824
139825
139826
139827
139828
139829
139830
139831
139832
139833
139834
139835
139836
139837
139838
139839
139840
139841
139842
139843
139844
139845
 
# File 'ext/ctp/ctp.cxx', line 139818

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



139788
139789
139790
139791
139792
139793
139794
139795
139796
139797
139798
139799
139800
139801
139802
139803
139804
139805
139806
139807
139808
139809
139810
139811
139812
139813
139814
139815
 
# File 'ext/ctp/ctp.cxx', line 139788

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



139758
139759
139760
139761
139762
139763
139764
139765
139766
139767
139768
139769
139770
139771
139772
139773
139774
139775
139776
139777
139778
139779
139780
139781
139782
139783
139784
139785
 
# File 'ext/ctp/ctp.cxx', line 139758

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



141239
141240
141241
141242
141243
141244
141245
141246
141247
141248
141249
141250
141251
141252
141253
141254
141255
141256
141257
141258
141259
141260
141261
141262
141263
141264
141265
141266
 
# File 'ext/ctp/ctp.cxx', line 141239

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



141209
141210
141211
141212
141213
141214
141215
141216
141217
141218
141219
141220
141221
141222
141223
141224
141225
141226
141227
141228
141229
141230
141231
141232
141233
141234
141235
141236
 
# File 'ext/ctp/ctp.cxx', line 141209

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



141817
141818
141819
141820
141821
141822
141823
141824
141825
141826
141827
141828
141829
141830
141831
141832
141833
141834
141835
141836
141837
141838
 
# File 'ext/ctp/ctp.cxx', line 141817

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

#BankPwdFlag=(*args) ⇒ Object 



141788
141789
141790
141791
141792
141793
141794
141795
141796
141797
141798
141799
141800
141801
141802
141803
141804
141805
141806
141807
141808
141809
141810
141811
141812
141813
141814
 
# File 'ext/ctp/ctp.cxx', line 141788

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

#BankSerial(*args) ⇒ Object 



140148
140149
140150
140151
140152
140153
140154
140155
140156
140157
140158
140159
140160
140161
140162
140163
140164
140165
140166
140167
140168
140169
140170
140171
140172
140173
140174
140175
 
# File 'ext/ctp/ctp.cxx', line 140148

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



140118
140119
140120
140121
140122
140123
140124
140125
140126
140127
140128
140129
140130
140131
140132
140133
140134
140135
140136
140137
140138
140139
140140
140141
140142
140143
140144
140145
 
# File 'ext/ctp/ctp.cxx', line 140118

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



139968
139969
139970
139971
139972
139973
139974
139975
139976
139977
139978
139979
139980
139981
139982
139983
139984
139985
139986
139987
139988
139989
139990
139991
139992
139993
139994
139995
 
# File 'ext/ctp/ctp.cxx', line 139968

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



139938
139939
139940
139941
139942
139943
139944
139945
139946
139947
139948
139949
139950
139951
139952
139953
139954
139955
139956
139957
139958
139959
139960
139961
139962
139963
139964
139965
 
# File 'ext/ctp/ctp.cxx', line 139938

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



139908
139909
139910
139911
139912
139913
139914
139915
139916
139917
139918
139919
139920
139921
139922
139923
139924
139925
139926
139927
139928
139929
139930
139931
139932
139933
139934
139935
 
# File 'ext/ctp/ctp.cxx', line 139908

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



139878
139879
139880
139881
139882
139883
139884
139885
139886
139887
139888
139889
139890
139891
139892
139893
139894
139895
139896
139897
139898
139899
139900
139901
139902
139903
139904
139905
 
# File 'ext/ctp/ctp.cxx', line 139878

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



141758
141759
141760
141761
141762
141763
141764
141765
141766
141767
141768
141769
141770
141771
141772
141773
141774
141775
141776
141777
141778
141779
141780
141781
141782
141783
141784
141785
 
# File 'ext/ctp/ctp.cxx', line 141758

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



141728
141729
141730
141731
141732
141733
141734
141735
141736
141737
141738
141739
141740
141741
141742
141743
141744
141745
141746
141747
141748
141749
141750
141751
141752
141753
141754
141755
 
# File 'ext/ctp/ctp.cxx', line 141728

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

#CountryCode(*args) ⇒ Object 



140653
140654
140655
140656
140657
140658
140659
140660
140661
140662
140663
140664
140665
140666
140667
140668
140669
140670
140671
140672
140673
140674
140675
140676
140677
140678
140679
140680
 
# File 'ext/ctp/ctp.cxx', line 140653

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



140623
140624
140625
140626
140627
140628
140629
140630
140631
140632
140633
140634
140635
140636
140637
140638
140639
140640
140641
140642
140643
140644
140645
140646
140647
140648
140649
140650
 
# File 'ext/ctp/ctp.cxx', line 140623

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



141698
141699
141700
141701
141702
141703
141704
141705
141706
141707
141708
141709
141710
141711
141712
141713
141714
141715
141716
141717
141718
141719
141720
141721
141722
141723
141724
141725
 
# File 'ext/ctp/ctp.cxx', line 141698

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



141668
141669
141670
141671
141672
141673
141674
141675
141676
141677
141678
141679
141680
141681
141682
141683
141684
141685
141686
141687
141688
141689
141690
141691
141692
141693
141694
141695
 
# File 'ext/ctp/ctp.cxx', line 141668

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



140427
140428
140429
140430
140431
140432
140433
140434
140435
140436
140437
140438
140439
140440
140441
140442
140443
140444
140445
140446
140447
140448
140449
140450
140451
140452
140453
140454
 
# File 'ext/ctp/ctp.cxx', line 140427

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



140397
140398
140399
140400
140401
140402
140403
140404
140405
140406
140407
140408
140409
140410
140411
140412
140413
140414
140415
140416
140417
140418
140419
140420
140421
140422
140423
140424
 
# File 'ext/ctp/ctp.cxx', line 140397

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



140712
140713
140714
140715
140716
140717
140718
140719
140720
140721
140722
140723
140724
140725
140726
140727
140728
140729
140730
140731
140732
140733
 
# File 'ext/ctp/ctp.cxx', line 140712

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

#CustType=(*args) ⇒ Object 



140683
140684
140685
140686
140687
140688
140689
140690
140691
140692
140693
140694
140695
140696
140697
140698
140699
140700
140701
140702
140703
140704
140705
140706
140707
140708
140709
 
# File 'ext/ctp/ctp.cxx', line 140683

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

#Digest(*args) ⇒ Object 



141977
141978
141979
141980
141981
141982
141983
141984
141985
141986
141987
141988
141989
141990
141991
141992
141993
141994
141995
141996
141997
141998
141999
142000
142001
142002
142003
142004
 
# File 'ext/ctp/ctp.cxx', line 141977

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



141947
141948
141949
141950
141951
141952
141953
141954
141955
141956
141957
141958
141959
141960
141961
141962
141963
141964
141965
141966
141967
141968
141969
141970
141971
141972
141973
141974
 
# File 'ext/ctp/ctp.cxx', line 141947

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



141066
141067
141068
141069
141070
141071
141072
141073
141074
141075
141076
141077
141078
141079
141080
141081
141082
141083
141084
141085
141086
141087
141088
141089
141090
141091
141092
141093
 
# File 'ext/ctp/ctp.cxx', line 141066

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



141036
141037
141038
141039
141040
141041
141042
141043
141044
141045
141046
141047
141048
141049
141050
141051
141052
141053
141054
141055
141056
141057
141058
141059
141060
141061
141062
141063
 
# File 'ext/ctp/ctp.cxx', line 141036

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



141006
141007
141008
141009
141010
141011
141012
141013
141014
141015
141016
141017
141018
141019
141020
141021
141022
141023
141024
141025
141026
141027
141028
141029
141030
141031
141032
141033
 
# File 'ext/ctp/ctp.cxx', line 141006

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



140976
140977
140978
140979
140980
140981
140982
140983
140984
140985
140986
140987
140988
140989
140990
140991
140992
140993
140994
140995
140996
140997
140998
140999
141000
141001
141002
141003
 
# File 'ext/ctp/ctp.cxx', line 140976

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



140599
140600
140601
140602
140603
140604
140605
140606
140607
140608
140609
140610
140611
140612
140613
140614
140615
140616
140617
140618
140619
140620
 
# File 'ext/ctp/ctp.cxx', line 140599

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

#Gender=(*args) ⇒ Object 



140570
140571
140572
140573
140574
140575
140576
140577
140578
140579
140580
140581
140582
140583
140584
140585
140586
140587
140588
140589
140590
140591
140592
140593
140594
140595
140596
 
# File 'ext/ctp/ctp.cxx', line 140570

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



140486
140487
140488
140489
140490
140491
140492
140493
140494
140495
140496
140497
140498
140499
140500
140501
140502
140503
140504
140505
140506
140507
 
# File 'ext/ctp/ctp.cxx', line 140486

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

#IdCardType=(*args) ⇒ Object 



140457
140458
140459
140460
140461
140462
140463
140464
140465
140466
140467
140468
140469
140470
140471
140472
140473
140474
140475
140476
140477
140478
140479
140480
140481
140482
140483
 
# File 'ext/ctp/ctp.cxx', line 140457

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



140540
140541
140542
140543
140544
140545
140546
140547
140548
140549
140550
140551
140552
140553
140554
140555
140556
140557
140558
140559
140560
140561
140562
140563
140564
140565
140566
140567
 
# File 'ext/ctp/ctp.cxx', line 140540

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



140510
140511
140512
140513
140514
140515
140516
140517
140518
140519
140520
140521
140522
140523
140524
140525
140526
140527
140528
140529
140530
140531
140532
140533
140534
140535
140536
140537
 
# File 'ext/ctp/ctp.cxx', line 140510

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



141591
141592
141593
141594
141595
141596
141597
141598
141599
141600
141601
141602
141603
141604
141605
141606
141607
141608
141609
141610
141611
141612
 
# File 'ext/ctp/ctp.cxx', line 141591

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

#InstallID=(*args) ⇒ Object 



141562
141563
141564
141565
141566
141567
141568
141569
141570
141571
141572
141573
141574
141575
141576
141577
141578
141579
141580
141581
141582
141583
141584
141585
141586
141587
141588
 
# File 'ext/ctp/ctp.cxx', line 141562

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



140320
140321
140322
140323
140324
140325
140326
140327
140328
140329
140330
140331
140332
140333
140334
140335
140336
140337
140338
140339
140340
140341
 
# File 'ext/ctp/ctp.cxx', line 140320

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

#LastFragment=(*args) ⇒ Object 



140291
140292
140293
140294
140295
140296
140297
140298
140299
140300
140301
140302
140303
140304
140305
140306
140307
140308
140309
140310
140311
140312
140313
140314
140315
140316
140317
 
# File 'ext/ctp/ctp.cxx', line 140291

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



140946
140947
140948
140949
140950
140951
140952
140953
140954
140955
140956
140957
140958
140959
140960
140961
140962
140963
140964
140965
140966
140967
140968
140969
140970
140971
140972
140973
 
# File 'ext/ctp/ctp.cxx', line 140946

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



140916
140917
140918
140919
140920
140921
140922
140923
140924
140925
140926
140927
140928
140929
140930
140931
140932
140933
140934
140935
140936
140937
140938
140939
140940
140941
140942
140943
 
# File 'ext/ctp/ctp.cxx', line 140916

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



141125
141126
141127
141128
141129
141130
141131
141132
141133
141134
141135
141136
141137
141138
141139
141140
141141
141142
141143
141144
141145
141146
 
# File 'ext/ctp/ctp.cxx', line 141125

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

#MoneyAccountStatus=(*args) ⇒ Object 



141096
141097
141098
141099
141100
141101
141102
141103
141104
141105
141106
141107
141108
141109
141110
141111
141112
141113
141114
141115
141116
141117
141118
141119
141120
141121
141122
 
# File 'ext/ctp/ctp.cxx', line 141096

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

#NewBankAccount(*args) ⇒ Object 



141299
141300
141301
141302
141303
141304
141305
141306
141307
141308
141309
141310
141311
141312
141313
141314
141315
141316
141317
141318
141319
141320
141321
141322
141323
141324
141325
141326
 
# File 'ext/ctp/ctp.cxx', line 141299

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

#NewBankAccount=(*args) ⇒ Object 



141269
141270
141271
141272
141273
141274
141275
141276
141277
141278
141279
141280
141281
141282
141283
141284
141285
141286
141287
141288
141289
141290
141291
141292
141293
141294
141295
141296
 
# File 'ext/ctp/ctp.cxx', line 141269

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

#NewBankPassWord(*args) ⇒ Object 



141359
141360
141361
141362
141363
141364
141365
141366
141367
141368
141369
141370
141371
141372
141373
141374
141375
141376
141377
141378
141379
141380
141381
141382
141383
141384
141385
141386
 
# File 'ext/ctp/ctp.cxx', line 141359

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

#NewBankPassWord=(*args) ⇒ Object 



141329
141330
141331
141332
141333
141334
141335
141336
141337
141338
141339
141340
141341
141342
141343
141344
141345
141346
141347
141348
141349
141350
141351
141352
141353
141354
141355
141356
 
# File 'ext/ctp/ctp.cxx', line 141329

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

#Password(*args) ⇒ Object 



141479
141480
141481
141482
141483
141484
141485
141486
141487
141488
141489
141490
141491
141492
141493
141494
141495
141496
141497
141498
141499
141500
141501
141502
141503
141504
141505
141506
 
# File 'ext/ctp/ctp.cxx', line 141479

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



141449
141450
141451
141452
141453
141454
141455
141456
141457
141458
141459
141460
141461
141462
141463
141464
141465
141466
141467
141468
141469
141470
141471
141472
141473
141474
141475
141476
 
# File 'ext/ctp/ctp.cxx', line 141449

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



140267
140268
140269
140270
140271
140272
140273
140274
140275
140276
140277
140278
140279
140280
140281
140282
140283
140284
140285
140286
140287
140288
 
# File 'ext/ctp/ctp.cxx', line 140267

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

#PlateSerial=(*args) ⇒ Object 



140238
140239
140240
140241
140242
140243
140244
140245
140246
140247
140248
140249
140250
140251
140252
140253
140254
140255
140256
140257
140258
140259
140260
140261
140262
140263
140264
 
# File 'ext/ctp/ctp.cxx', line 140238

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



141870
141871
141872
141873
141874
141875
141876
141877
141878
141879
141880
141881
141882
141883
141884
141885
141886
141887
141888
141889
141890
141891
 
# File 'ext/ctp/ctp.cxx', line 141870

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

#SecuPwdFlag=(*args) ⇒ Object 



141841
141842
141843
141844
141845
141846
141847
141848
141849
141850
141851
141852
141853
141854
141855
141856
141857
141858
141859
141860
141861
141862
141863
141864
141865
141866
141867
 
# File 'ext/ctp/ctp.cxx', line 141841

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



140373
140374
140375
140376
140377
140378
140379
140380
140381
140382
140383
140384
140385
140386
140387
140388
140389
140390
140391
140392
140393
140394
 
# File 'ext/ctp/ctp.cxx', line 140373

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

#SessionID=(*args) ⇒ Object 



140344
140345
140346
140347
140348
140349
140350
140351
140352
140353
140354
140355
140356
140357
140358
140359
140360
140361
140362
140363
140364
140365
140366
140367
140368
140369
140370
 
# File 'ext/ctp/ctp.cxx', line 140344

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



140886
140887
140888
140889
140890
140891
140892
140893
140894
140895
140896
140897
140898
140899
140900
140901
140902
140903
140904
140905
140906
140907
140908
140909
140910
140911
140912
140913
 
# File 'ext/ctp/ctp.cxx', line 140886

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



140856
140857
140858
140859
140860
140861
140862
140863
140864
140865
140866
140867
140868
140869
140870
140871
140872
140873
140874
140875
140876
140877
140878
140879
140880
140881
140882
140883
 
# File 'ext/ctp/ctp.cxx', line 140856

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



141923
141924
141925
141926
141927
141928
141929
141930
141931
141932
141933
141934
141935
141936
141937
141938
141939
141940
141941
141942
141943
141944
 
# File 'ext/ctp/ctp.cxx', line 141923

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

#TID=(*args) ⇒ Object 



141894
141895
141896
141897
141898
141899
141900
141901
141902
141903
141904
141905
141906
141907
141908
141909
141910
141911
141912
141913
141914
141915
141916
141917
141918
141919
141920
 
# File 'ext/ctp/ctp.cxx', line 141894

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



139728
139729
139730
139731
139732
139733
139734
139735
139736
139737
139738
139739
139740
139741
139742
139743
139744
139745
139746
139747
139748
139749
139750
139751
139752
139753
139754
139755
 
# File 'ext/ctp/ctp.cxx', line 139728

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



139698
139699
139700
139701
139702
139703
139704
139705
139706
139707
139708
139709
139710
139711
139712
139713
139714
139715
139716
139717
139718
139719
139720
139721
139722
139723
139724
139725
 
# File 'ext/ctp/ctp.cxx', line 139698

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



140028
140029
140030
140031
140032
140033
140034
140035
140036
140037
140038
140039
140040
140041
140042
140043
140044
140045
140046
140047
140048
140049
140050
140051
140052
140053
140054
140055
 
# File 'ext/ctp/ctp.cxx', line 140028

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



139998
139999
140000
140001
140002
140003
140004
140005
140006
140007
140008
140009
140010
140011
140012
140013
140014
140015
140016
140017
140018
140019
140020
140021
140022
140023
140024
140025
 
# File 'ext/ctp/ctp.cxx', line 139998

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



140088
140089
140090
140091
140092
140093
140094
140095
140096
140097
140098
140099
140100
140101
140102
140103
140104
140105
140106
140107
140108
140109
140110
140111
140112
140113
140114
140115
 
# File 'ext/ctp/ctp.cxx', line 140088

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



140058
140059
140060
140061
140062
140063
140064
140065
140066
140067
140068
140069
140070
140071
140072
140073
140074
140075
140076
140077
140078
140079
140080
140081
140082
140083
140084
140085
 
# File 'ext/ctp/ctp.cxx', line 140058

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



140208
140209
140210
140211
140212
140213
140214
140215
140216
140217
140218
140219
140220
140221
140222
140223
140224
140225
140226
140227
140228
140229
140230
140231
140232
140233
140234
140235
 
# File 'ext/ctp/ctp.cxx', line 140208

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



140178
140179
140180
140181
140182
140183
140184
140185
140186
140187
140188
140189
140190
140191
140192
140193
140194
140195
140196
140197
140198
140199
140200
140201
140202
140203
140204
140205
 
# File 'ext/ctp/ctp.cxx', line 140178

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

#VerifyCertNoFlag(*args) ⇒ Object 



141644
141645
141646
141647
141648
141649
141650
141651
141652
141653
141654
141655
141656
141657
141658
141659
141660
141661
141662
141663
141664
141665
 
# File 'ext/ctp/ctp.cxx', line 141644

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

#VerifyCertNoFlag=(*args) ⇒ Object 



141615
141616
141617
141618
141619
141620
141621
141622
141623
141624
141625
141626
141627
141628
141629
141630
141631
141632
141633
141634
141635
141636
141637
141638
141639
141640
141641
 
# File 'ext/ctp/ctp.cxx', line 141615

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



140826
140827
140828
140829
140830
140831
140832
140833
140834
140835
140836
140837
140838
140839
140840
140841
140842
140843
140844
140845
140846
140847
140848
140849
140850
140851
140852
140853
 
# File 'ext/ctp/ctp.cxx', line 140826

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



140796
140797
140798
140799
140800
140801
140802
140803
140804
140805
140806
140807
140808
140809
140810
140811
140812
140813
140814
140815
140816
140817
140818
140819
140820
140821
140822
140823
 
# File 'ext/ctp/ctp.cxx', line 140796

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