Class: Ctp::CThostFtdcCancelAccountField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



186659
186660
186661
186662
186663
186664
186665
186666
186667
186668
186669
186670
186671
186672
 
# File 'ext/ctp/ctp.cxx', line 186659

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

Instance Method Details

#AccountID(*args) ⇒ Object 



185597
185598
185599
185600
185601
185602
185603
185604
185605
185606
185607
185608
185609
185610
185611
185612
185613
185614
185615
185616
185617
185618
185619
185620
185621
185622
185623
185624
 
# File 'ext/ctp/ctp.cxx', line 185597

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



185567
185568
185569
185570
185571
185572
185573
185574
185575
185576
185577
185578
185579
185580
185581
185582
185583
185584
185585
185586
185587
185588
185589
185590
185591
185592
185593
185594
 
# File 'ext/ctp/ctp.cxx', line 185567

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



185064
185065
185066
185067
185068
185069
185070
185071
185072
185073
185074
185075
185076
185077
185078
185079
185080
185081
185082
185083
185084
185085
185086
185087
185088
185089
185090
185091
 
# File 'ext/ctp/ctp.cxx', line 185064

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



185034
185035
185036
185037
185038
185039
185040
185041
185042
185043
185044
185045
185046
185047
185048
185049
185050
185051
185052
185053
185054
185055
185056
185057
185058
185059
185060
185061
 
# File 'ext/ctp/ctp.cxx', line 185034

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



185477
185478
185479
185480
185481
185482
185483
185484
185485
185486
185487
185488
185489
185490
185491
185492
185493
185494
185495
185496
185497
185498
185499
185500
185501
185502
185503
185504
 
# File 'ext/ctp/ctp.cxx', line 185477

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



185447
185448
185449
185450
185451
185452
185453
185454
185455
185456
185457
185458
185459
185460
185461
185462
185463
185464
185465
185466
185467
185468
185469
185470
185471
185472
185473
185474
 
# File 'ext/ctp/ctp.cxx', line 185447

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



185995
185996
185997
185998
185999
186000
186001
186002
186003
186004
186005
186006
186007
186008
186009
186010
186011
186012
186013
186014
186015
186016
 
# File 'ext/ctp/ctp.cxx', line 185995

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

#BankAccType=(*args) ⇒ Object 



185966
185967
185968
185969
185970
185971
185972
185973
185974
185975
185976
185977
185978
185979
185980
185981
185982
185983
185984
185985
185986
185987
185988
185989
185990
185991
185992
 
# File 'ext/ctp/ctp.cxx', line 185966

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



184146
184147
184148
184149
184150
184151
184152
184153
184154
184155
184156
184157
184158
184159
184160
184161
184162
184163
184164
184165
184166
184167
184168
184169
184170
184171
184172
184173
 
# File 'ext/ctp/ctp.cxx', line 184146

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



184116
184117
184118
184119
184120
184121
184122
184123
184124
184125
184126
184127
184128
184129
184130
184131
184132
184133
184134
184135
184136
184137
184138
184139
184140
184141
184142
184143
 
# File 'ext/ctp/ctp.cxx', line 184116

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



184086
184087
184088
184089
184090
184091
184092
184093
184094
184095
184096
184097
184098
184099
184100
184101
184102
184103
184104
184105
184106
184107
184108
184109
184110
184111
184112
184113
 
# File 'ext/ctp/ctp.cxx', line 184086

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



184056
184057
184058
184059
184060
184061
184062
184063
184064
184065
184066
184067
184068
184069
184070
184071
184072
184073
184074
184075
184076
184077
184078
184079
184080
184081
184082
184083
 
# File 'ext/ctp/ctp.cxx', line 184056

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



185537
185538
185539
185540
185541
185542
185543
185544
185545
185546
185547
185548
185549
185550
185551
185552
185553
185554
185555
185556
185557
185558
185559
185560
185561
185562
185563
185564
 
# File 'ext/ctp/ctp.cxx', line 185537

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



185507
185508
185509
185510
185511
185512
185513
185514
185515
185516
185517
185518
185519
185520
185521
185522
185523
185524
185525
185526
185527
185528
185529
185530
185531
185532
185533
185534
 
# File 'ext/ctp/ctp.cxx', line 185507

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



186281
186282
186283
186284
186285
186286
186287
186288
186289
186290
186291
186292
186293
186294
186295
186296
186297
186298
186299
186300
186301
186302
 
# File 'ext/ctp/ctp.cxx', line 186281

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

#BankPwdFlag=(*args) ⇒ Object 



186252
186253
186254
186255
186256
186257
186258
186259
186260
186261
186262
186263
186264
186265
186266
186267
186268
186269
186270
186271
186272
186273
186274
186275
186276
186277
186278
 
# File 'ext/ctp/ctp.cxx', line 186252

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

#BankSecuAcc(*args) ⇒ Object 



186222
186223
186224
186225
186226
186227
186228
186229
186230
186231
186232
186233
186234
186235
186236
186237
186238
186239
186240
186241
186242
186243
186244
186245
186246
186247
186248
186249
 
# File 'ext/ctp/ctp.cxx', line 186222

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

#BankSecuAcc=(*args) ⇒ Object 



186192
186193
186194
186195
186196
186197
186198
186199
186200
186201
186202
186203
186204
186205
186206
186207
186208
186209
186210
186211
186212
186213
186214
186215
186216
186217
186218
186219
 
# File 'ext/ctp/ctp.cxx', line 186192

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

#BankSecuAccType(*args) ⇒ Object 



186108
186109
186110
186111
186112
186113
186114
186115
186116
186117
186118
186119
186120
186121
186122
186123
186124
186125
186126
186127
186128
186129
 
# File 'ext/ctp/ctp.cxx', line 186108

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

#BankSecuAccType=(*args) ⇒ Object 



186079
186080
186081
186082
186083
186084
186085
186086
186087
186088
186089
186090
186091
186092
186093
186094
186095
186096
186097
186098
186099
186100
186101
186102
186103
186104
186105
 
# File 'ext/ctp/ctp.cxx', line 186079

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

#BankSerial(*args) ⇒ Object 



184446
184447
184448
184449
184450
184451
184452
184453
184454
184455
184456
184457
184458
184459
184460
184461
184462
184463
184464
184465
184466
184467
184468
184469
184470
184471
184472
184473
 
# File 'ext/ctp/ctp.cxx', line 184446

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



184416
184417
184418
184419
184420
184421
184422
184423
184424
184425
184426
184427
184428
184429
184430
184431
184432
184433
184434
184435
184436
184437
184438
184439
184440
184441
184442
184443
 
# File 'ext/ctp/ctp.cxx', line 184416

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



184266
184267
184268
184269
184270
184271
184272
184273
184274
184275
184276
184277
184278
184279
184280
184281
184282
184283
184284
184285
184286
184287
184288
184289
184290
184291
184292
184293
 
# File 'ext/ctp/ctp.cxx', line 184266

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



184236
184237
184238
184239
184240
184241
184242
184243
184244
184245
184246
184247
184248
184249
184250
184251
184252
184253
184254
184255
184256
184257
184258
184259
184260
184261
184262
184263
 
# File 'ext/ctp/ctp.cxx', line 184236

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



184206
184207
184208
184209
184210
184211
184212
184213
184214
184215
184216
184217
184218
184219
184220
184221
184222
184223
184224
184225
184226
184227
184228
184229
184230
184231
184232
184233
 
# File 'ext/ctp/ctp.cxx', line 184206

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



184176
184177
184178
184179
184180
184181
184182
184183
184184
184185
184186
184187
184188
184189
184190
184191
184192
184193
184194
184195
184196
184197
184198
184199
184200
184201
184202
184203
 
# File 'ext/ctp/ctp.cxx', line 184176

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



186162
186163
186164
186165
186166
186167
186168
186169
186170
186171
186172
186173
186174
186175
186176
186177
186178
186179
186180
186181
186182
186183
186184
186185
186186
186187
186188
186189
 
# File 'ext/ctp/ctp.cxx', line 186162

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



186132
186133
186134
186135
186136
186137
186138
186139
186140
186141
186142
186143
186144
186145
186146
186147
186148
186149
186150
186151
186152
186153
186154
186155
186156
186157
186158
186159
 
# File 'ext/ctp/ctp.cxx', line 186132

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

#CashExchangeCode(*args) ⇒ Object 



185882
185883
185884
185885
185886
185887
185888
185889
185890
185891
185892
185893
185894
185895
185896
185897
185898
185899
185900
185901
185902
185903
 
# File 'ext/ctp/ctp.cxx', line 185882

SWIGINTERN VALUE
_wrap_CThostFtdcCancelAccountField_CashExchangeCode_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcCancelAccountField *arg1 = (CThostFtdcCancelAccountField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcCashExchangeCodeType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcCancelAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcCancelAccountField *","CashExchangeCode", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcCancelAccountField * >(argp1);
  result = (TThostFtdcCashExchangeCodeType) ((arg1)->CashExchangeCode);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#CashExchangeCode=(*args) ⇒ Object 



185853
185854
185855
185856
185857
185858
185859
185860
185861
185862
185863
185864
185865
185866
185867
185868
185869
185870
185871
185872
185873
185874
185875
185876
185877
185878
185879
 
# File 'ext/ctp/ctp.cxx', line 185853

SWIGINTERN VALUE
_wrap_CThostFtdcCancelAccountField_CashExchangeCode_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcCancelAccountField *arg1 = (CThostFtdcCancelAccountField *) 0 ;
  TThostFtdcCashExchangeCodeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcCancelAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcCancelAccountField *","CashExchangeCode", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcCancelAccountField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcCashExchangeCodeType","CashExchangeCode", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcCashExchangeCodeType >(val2);
  if (arg1) (arg1)->CashExchangeCode = arg2;
  return Qnil;
fail:
  return Qnil;
}

#CountryCode(*args) ⇒ Object 



184951
184952
184953
184954
184955
184956
184957
184958
184959
184960
184961
184962
184963
184964
184965
184966
184967
184968
184969
184970
184971
184972
184973
184974
184975
184976
184977
184978
 
# File 'ext/ctp/ctp.cxx', line 184951

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



184921
184922
184923
184924
184925
184926
184927
184928
184929
184930
184931
184932
184933
184934
184935
184936
184937
184938
184939
184940
184941
184942
184943
184944
184945
184946
184947
184948
 
# File 'ext/ctp/ctp.cxx', line 184921

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



185823
185824
185825
185826
185827
185828
185829
185830
185831
185832
185833
185834
185835
185836
185837
185838
185839
185840
185841
185842
185843
185844
185845
185846
185847
185848
185849
185850
 
# File 'ext/ctp/ctp.cxx', line 185823

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



185793
185794
185795
185796
185797
185798
185799
185800
185801
185802
185803
185804
185805
185806
185807
185808
185809
185810
185811
185812
185813
185814
185815
185816
185817
185818
185819
185820
 
# File 'ext/ctp/ctp.cxx', line 185793

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



184725
184726
184727
184728
184729
184730
184731
184732
184733
184734
184735
184736
184737
184738
184739
184740
184741
184742
184743
184744
184745
184746
184747
184748
184749
184750
184751
184752
 
# File 'ext/ctp/ctp.cxx', line 184725

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



184695
184696
184697
184698
184699
184700
184701
184702
184703
184704
184705
184706
184707
184708
184709
184710
184711
184712
184713
184714
184715
184716
184717
184718
184719
184720
184721
184722
 
# File 'ext/ctp/ctp.cxx', line 184695

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



185010
185011
185012
185013
185014
185015
185016
185017
185018
185019
185020
185021
185022
185023
185024
185025
185026
185027
185028
185029
185030
185031
 
# File 'ext/ctp/ctp.cxx', line 185010

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

#CustType=(*args) ⇒ Object 



184981
184982
184983
184984
184985
184986
184987
184988
184989
184990
184991
184992
184993
184994
184995
184996
184997
184998
184999
185000
185001
185002
185003
185004
185005
185006
185007
 
# File 'ext/ctp/ctp.cxx', line 184981

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

#DeviceID(*args) ⇒ Object 



186049
186050
186051
186052
186053
186054
186055
186056
186057
186058
186059
186060
186061
186062
186063
186064
186065
186066
186067
186068
186069
186070
186071
186072
186073
186074
186075
186076
 
# File 'ext/ctp/ctp.cxx', line 186049

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

#DeviceID=(*args) ⇒ Object 



186019
186020
186021
186022
186023
186024
186025
186026
186027
186028
186029
186030
186031
186032
186033
186034
186035
186036
186037
186038
186039
186040
186041
186042
186043
186044
186045
186046
 
# File 'ext/ctp/ctp.cxx', line 186019

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

#Digest(*args) ⇒ Object 



185936
185937
185938
185939
185940
185941
185942
185943
185944
185945
185946
185947
185948
185949
185950
185951
185952
185953
185954
185955
185956
185957
185958
185959
185960
185961
185962
185963
 
# File 'ext/ctp/ctp.cxx', line 185936

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



185906
185907
185908
185909
185910
185911
185912
185913
185914
185915
185916
185917
185918
185919
185920
185921
185922
185923
185924
185925
185926
185927
185928
185929
185930
185931
185932
185933
 
# File 'ext/ctp/ctp.cxx', line 185906

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



185364
185365
185366
185367
185368
185369
185370
185371
185372
185373
185374
185375
185376
185377
185378
185379
185380
185381
185382
185383
185384
185385
185386
185387
185388
185389
185390
185391
 
# File 'ext/ctp/ctp.cxx', line 185364

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



185334
185335
185336
185337
185338
185339
185340
185341
185342
185343
185344
185345
185346
185347
185348
185349
185350
185351
185352
185353
185354
185355
185356
185357
185358
185359
185360
185361
 
# File 'ext/ctp/ctp.cxx', line 185334

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

#ErrorID(*args) ⇒ Object 



186560
186561
186562
186563
186564
186565
186566
186567
186568
186569
186570
186571
186572
186573
186574
186575
186576
186577
186578
186579
186580
186581
 
# File 'ext/ctp/ctp.cxx', line 186560

SWIGINTERN VALUE
_wrap_CThostFtdcCancelAccountField_ErrorID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcCancelAccountField *arg1 = (CThostFtdcCancelAccountField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcErrorIDType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcCancelAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcCancelAccountField *","ErrorID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcCancelAccountField * >(argp1);
  result = (TThostFtdcErrorIDType) ((arg1)->ErrorID);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#ErrorID=(*args) ⇒ Object 



186531
186532
186533
186534
186535
186536
186537
186538
186539
186540
186541
186542
186543
186544
186545
186546
186547
186548
186549
186550
186551
186552
186553
186554
186555
186556
186557
 
# File 'ext/ctp/ctp.cxx', line 186531

SWIGINTERN VALUE
_wrap_CThostFtdcCancelAccountField_ErrorID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcCancelAccountField *arg1 = (CThostFtdcCancelAccountField *) 0 ;
  TThostFtdcErrorIDType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcCancelAccountField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcCancelAccountField *","ErrorID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcCancelAccountField * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcErrorIDType","ErrorID", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcErrorIDType >(val2);
  if (arg1) (arg1)->ErrorID = arg2;
  return Qnil;
fail:
  return Qnil;
}

#ErrorMsg(*args) ⇒ Object 



186614
186615
186616
186617
186618
186619
186620
186621
186622
186623
186624
186625
186626
186627
186628
186629
186630
186631
186632
186633
186634
186635
186636
186637
186638
186639
186640
186641
 
# File 'ext/ctp/ctp.cxx', line 186614

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

#ErrorMsg=(*args) ⇒ Object 



186584
186585
186586
186587
186588
186589
186590
186591
186592
186593
186594
186595
186596
186597
186598
186599
186600
186601
186602
186603
186604
186605
186606
186607
186608
186609
186610
186611
 
# File 'ext/ctp/ctp.cxx', line 186584

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

#Fax(*args) ⇒ Object 



185304
185305
185306
185307
185308
185309
185310
185311
185312
185313
185314
185315
185316
185317
185318
185319
185320
185321
185322
185323
185324
185325
185326
185327
185328
185329
185330
185331
 
# File 'ext/ctp/ctp.cxx', line 185304

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



185274
185275
185276
185277
185278
185279
185280
185281
185282
185283
185284
185285
185286
185287
185288
185289
185290
185291
185292
185293
185294
185295
185296
185297
185298
185299
185300
185301
 
# File 'ext/ctp/ctp.cxx', line 185274

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



184897
184898
184899
184900
184901
184902
184903
184904
184905
184906
184907
184908
184909
184910
184911
184912
184913
184914
184915
184916
184917
184918
 
# File 'ext/ctp/ctp.cxx', line 184897

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

#Gender=(*args) ⇒ Object 



184868
184869
184870
184871
184872
184873
184874
184875
184876
184877
184878
184879
184880
184881
184882
184883
184884
184885
184886
184887
184888
184889
184890
184891
184892
184893
184894
 
# File 'ext/ctp/ctp.cxx', line 184868

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



184784
184785
184786
184787
184788
184789
184790
184791
184792
184793
184794
184795
184796
184797
184798
184799
184800
184801
184802
184803
184804
184805
 
# File 'ext/ctp/ctp.cxx', line 184784

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

#IdCardType=(*args) ⇒ Object 



184755
184756
184757
184758
184759
184760
184761
184762
184763
184764
184765
184766
184767
184768
184769
184770
184771
184772
184773
184774
184775
184776
184777
184778
184779
184780
184781
 
# File 'ext/ctp/ctp.cxx', line 184755

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



184838
184839
184840
184841
184842
184843
184844
184845
184846
184847
184848
184849
184850
184851
184852
184853
184854
184855
184856
184857
184858
184859
184860
184861
184862
184863
184864
184865
 
# File 'ext/ctp/ctp.cxx', line 184838

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



184808
184809
184810
184811
184812
184813
184814
184815
184816
184817
184818
184819
184820
184821
184822
184823
184824
184825
184826
184827
184828
184829
184830
184831
184832
184833
184834
184835
 
# File 'ext/ctp/ctp.cxx', line 184808

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



185716
185717
185718
185719
185720
185721
185722
185723
185724
185725
185726
185727
185728
185729
185730
185731
185732
185733
185734
185735
185736
185737
 
# File 'ext/ctp/ctp.cxx', line 185716

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

#InstallID=(*args) ⇒ Object 



185687
185688
185689
185690
185691
185692
185693
185694
185695
185696
185697
185698
185699
185700
185701
185702
185703
185704
185705
185706
185707
185708
185709
185710
185711
185712
185713
 
# File 'ext/ctp/ctp.cxx', line 185687

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



184618
184619
184620
184621
184622
184623
184624
184625
184626
184627
184628
184629
184630
184631
184632
184633
184634
184635
184636
184637
184638
184639
 
# File 'ext/ctp/ctp.cxx', line 184618

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

#LastFragment=(*args) ⇒ Object 



184589
184590
184591
184592
184593
184594
184595
184596
184597
184598
184599
184600
184601
184602
184603
184604
184605
184606
184607
184608
184609
184610
184611
184612
184613
184614
184615
 
# File 'ext/ctp/ctp.cxx', line 184589

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



185244
185245
185246
185247
185248
185249
185250
185251
185252
185253
185254
185255
185256
185257
185258
185259
185260
185261
185262
185263
185264
185265
185266
185267
185268
185269
185270
185271
 
# File 'ext/ctp/ctp.cxx', line 185244

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



185214
185215
185216
185217
185218
185219
185220
185221
185222
185223
185224
185225
185226
185227
185228
185229
185230
185231
185232
185233
185234
185235
185236
185237
185238
185239
185240
185241
 
# File 'ext/ctp/ctp.cxx', line 185214

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



185423
185424
185425
185426
185427
185428
185429
185430
185431
185432
185433
185434
185435
185436
185437
185438
185439
185440
185441
185442
185443
185444
 
# File 'ext/ctp/ctp.cxx', line 185423

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

#MoneyAccountStatus=(*args) ⇒ Object 



185394
185395
185396
185397
185398
185399
185400
185401
185402
185403
185404
185405
185406
185407
185408
185409
185410
185411
185412
185413
185414
185415
185416
185417
185418
185419
185420
 
# File 'ext/ctp/ctp.cxx', line 185394

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

#OperNo(*args) ⇒ Object 



186388
186389
186390
186391
186392
186393
186394
186395
186396
186397
186398
186399
186400
186401
186402
186403
186404
186405
186406
186407
186408
186409
186410
186411
186412
186413
186414
186415
 
# File 'ext/ctp/ctp.cxx', line 186388

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

#OperNo=(*args) ⇒ Object 



186358
186359
186360
186361
186362
186363
186364
186365
186366
186367
186368
186369
186370
186371
186372
186373
186374
186375
186376
186377
186378
186379
186380
186381
186382
186383
186384
186385
 
# File 'ext/ctp/ctp.cxx', line 186358

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

#Password(*args) ⇒ Object 



185657
185658
185659
185660
185661
185662
185663
185664
185665
185666
185667
185668
185669
185670
185671
185672
185673
185674
185675
185676
185677
185678
185679
185680
185681
185682
185683
185684
 
# File 'ext/ctp/ctp.cxx', line 185657

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



185627
185628
185629
185630
185631
185632
185633
185634
185635
185636
185637
185638
185639
185640
185641
185642
185643
185644
185645
185646
185647
185648
185649
185650
185651
185652
185653
185654
 
# File 'ext/ctp/ctp.cxx', line 185627

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



184565
184566
184567
184568
184569
184570
184571
184572
184573
184574
184575
184576
184577
184578
184579
184580
184581
184582
184583
184584
184585
184586
 
# File 'ext/ctp/ctp.cxx', line 184565

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

#PlateSerial=(*args) ⇒ Object 



184536
184537
184538
184539
184540
184541
184542
184543
184544
184545
184546
184547
184548
184549
184550
184551
184552
184553
184554
184555
184556
184557
184558
184559
184560
184561
184562
 
# File 'ext/ctp/ctp.cxx', line 184536

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



186334
186335
186336
186337
186338
186339
186340
186341
186342
186343
186344
186345
186346
186347
186348
186349
186350
186351
186352
186353
186354
186355
 
# File 'ext/ctp/ctp.cxx', line 186334

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

#SecuPwdFlag=(*args) ⇒ Object 



186305
186306
186307
186308
186309
186310
186311
186312
186313
186314
186315
186316
186317
186318
186319
186320
186321
186322
186323
186324
186325
186326
186327
186328
186329
186330
186331
 
# File 'ext/ctp/ctp.cxx', line 186305

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



184671
184672
184673
184674
184675
184676
184677
184678
184679
184680
184681
184682
184683
184684
184685
184686
184687
184688
184689
184690
184691
184692
 
# File 'ext/ctp/ctp.cxx', line 184671

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

#SessionID=(*args) ⇒ Object 



184642
184643
184644
184645
184646
184647
184648
184649
184650
184651
184652
184653
184654
184655
184656
184657
184658
184659
184660
184661
184662
184663
184664
184665
184666
184667
184668
 
# File 'ext/ctp/ctp.cxx', line 184642

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



185184
185185
185186
185187
185188
185189
185190
185191
185192
185193
185194
185195
185196
185197
185198
185199
185200
185201
185202
185203
185204
185205
185206
185207
185208
185209
185210
185211
 
# File 'ext/ctp/ctp.cxx', line 185184

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



185154
185155
185156
185157
185158
185159
185160
185161
185162
185163
185164
185165
185166
185167
185168
185169
185170
185171
185172
185173
185174
185175
185176
185177
185178
185179
185180
185181
 
# File 'ext/ctp/ctp.cxx', line 185154

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



186447
186448
186449
186450
186451
186452
186453
186454
186455
186456
186457
186458
186459
186460
186461
186462
186463
186464
186465
186466
186467
186468
 
# File 'ext/ctp/ctp.cxx', line 186447

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

#TID=(*args) ⇒ Object 



186418
186419
186420
186421
186422
186423
186424
186425
186426
186427
186428
186429
186430
186431
186432
186433
186434
186435
186436
186437
186438
186439
186440
186441
186442
186443
186444
 
# File 'ext/ctp/ctp.cxx', line 186418

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



184026
184027
184028
184029
184030
184031
184032
184033
184034
184035
184036
184037
184038
184039
184040
184041
184042
184043
184044
184045
184046
184047
184048
184049
184050
184051
184052
184053
 
# File 'ext/ctp/ctp.cxx', line 184026

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



183996
183997
183998
183999
184000
184001
184002
184003
184004
184005
184006
184007
184008
184009
184010
184011
184012
184013
184014
184015
184016
184017
184018
184019
184020
184021
184022
184023
 
# File 'ext/ctp/ctp.cxx', line 183996

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



184326
184327
184328
184329
184330
184331
184332
184333
184334
184335
184336
184337
184338
184339
184340
184341
184342
184343
184344
184345
184346
184347
184348
184349
184350
184351
184352
184353
 
# File 'ext/ctp/ctp.cxx', line 184326

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



184296
184297
184298
184299
184300
184301
184302
184303
184304
184305
184306
184307
184308
184309
184310
184311
184312
184313
184314
184315
184316
184317
184318
184319
184320
184321
184322
184323
 
# File 'ext/ctp/ctp.cxx', line 184296

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



184386
184387
184388
184389
184390
184391
184392
184393
184394
184395
184396
184397
184398
184399
184400
184401
184402
184403
184404
184405
184406
184407
184408
184409
184410
184411
184412
184413
 
# File 'ext/ctp/ctp.cxx', line 184386

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



184356
184357
184358
184359
184360
184361
184362
184363
184364
184365
184366
184367
184368
184369
184370
184371
184372
184373
184374
184375
184376
184377
184378
184379
184380
184381
184382
184383
 
# File 'ext/ctp/ctp.cxx', line 184356

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



184506
184507
184508
184509
184510
184511
184512
184513
184514
184515
184516
184517
184518
184519
184520
184521
184522
184523
184524
184525
184526
184527
184528
184529
184530
184531
184532
184533
 
# File 'ext/ctp/ctp.cxx', line 184506

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



184476
184477
184478
184479
184480
184481
184482
184483
184484
184485
184486
184487
184488
184489
184490
184491
184492
184493
184494
184495
184496
184497
184498
184499
184500
184501
184502
184503
 
# File 'ext/ctp/ctp.cxx', line 184476

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

#UserID(*args) ⇒ Object 



186501
186502
186503
186504
186505
186506
186507
186508
186509
186510
186511
186512
186513
186514
186515
186516
186517
186518
186519
186520
186521
186522
186523
186524
186525
186526
186527
186528
 
# File 'ext/ctp/ctp.cxx', line 186501

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

#UserID=(*args) ⇒ Object 



186471
186472
186473
186474
186475
186476
186477
186478
186479
186480
186481
186482
186483
186484
186485
186486
186487
186488
186489
186490
186491
186492
186493
186494
186495
186496
186497
186498
 
# File 'ext/ctp/ctp.cxx', line 186471

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

#VerifyCertNoFlag(*args) ⇒ Object 



185769
185770
185771
185772
185773
185774
185775
185776
185777
185778
185779
185780
185781
185782
185783
185784
185785
185786
185787
185788
185789
185790
 
# File 'ext/ctp/ctp.cxx', line 185769

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

#VerifyCertNoFlag=(*args) ⇒ Object 



185740
185741
185742
185743
185744
185745
185746
185747
185748
185749
185750
185751
185752
185753
185754
185755
185756
185757
185758
185759
185760
185761
185762
185763
185764
185765
185766
 
# File 'ext/ctp/ctp.cxx', line 185740

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



185124
185125
185126
185127
185128
185129
185130
185131
185132
185133
185134
185135
185136
185137
185138
185139
185140
185141
185142
185143
185144
185145
185146
185147
185148
185149
185150
185151
 
# File 'ext/ctp/ctp.cxx', line 185124

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



185094
185095
185096
185097
185098
185099
185100
185101
185102
185103
185104
185105
185106
185107
185108
185109
185110
185111
185112
185113
185114
185115
185116
185117
185118
185119
185120
185121
 
# File 'ext/ctp/ctp.cxx', line 185094

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