Class: Ctp::CThostFtdcTransferSerialField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



175473
175474
175475
175476
175477
175478
175479
175480
175481
175482
175483
175484
175485
175486
 
# File 'ext/ctp/ctp.cxx', line 175473

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

Instance Method Details

#AccountID(*args) ⇒ Object 



174697
174698
174699
174700
174701
174702
174703
174704
174705
174706
174707
174708
174709
174710
174711
174712
174713
174714
174715
174716
174717
174718
174719
174720
174721
174722
174723
174724
 
# File 'ext/ctp/ctp.cxx', line 174697

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



174667
174668
174669
174670
174671
174672
174673
174674
174675
174676
174677
174678
174679
174680
174681
174682
174683
174684
174685
174686
174687
174688
174689
174690
174691
174692
174693
174694
 
# File 'ext/ctp/ctp.cxx', line 174667

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

#AvailabilityFlag(*args) ⇒ Object 



175201
175202
175203
175204
175205
175206
175207
175208
175209
175210
175211
175212
175213
175214
175215
175216
175217
175218
175219
175220
175221
175222
 
# File 'ext/ctp/ctp.cxx', line 175201

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

#AvailabilityFlag=(*args) ⇒ Object 



175172
175173
175174
175175
175176
175177
175178
175179
175180
175181
175182
175183
175184
175185
175186
175187
175188
175189
175190
175191
175192
175193
175194
175195
175196
175197
175198
 
# File 'ext/ctp/ctp.cxx', line 175172

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

#BankAccount(*args) ⇒ Object 



174404
174405
174406
174407
174408
174409
174410
174411
174412
174413
174414
174415
174416
174417
174418
174419
174420
174421
174422
174423
174424
174425
174426
174427
174428
174429
174430
174431
 
# File 'ext/ctp/ctp.cxx', line 174404

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



174374
174375
174376
174377
174378
174379
174380
174381
174382
174383
174384
174385
174386
174387
174388
174389
174390
174391
174392
174393
174394
174395
174396
174397
174398
174399
174400
174401
 
# File 'ext/ctp/ctp.cxx', line 174374

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



174350
174351
174352
174353
174354
174355
174356
174357
174358
174359
174360
174361
174362
174363
174364
174365
174366
174367
174368
174369
174370
174371
 
# File 'ext/ctp/ctp.cxx', line 174350

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

#BankAccType=(*args) ⇒ Object 



174321
174322
174323
174324
174325
174326
174327
174328
174329
174330
174331
174332
174333
174334
174335
174336
174337
174338
174339
174340
174341
174342
174343
174344
174345
174346
174347
 
# File 'ext/ctp/ctp.cxx', line 174321

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



174291
174292
174293
174294
174295
174296
174297
174298
174299
174300
174301
174302
174303
174304
174305
174306
174307
174308
174309
174310
174311
174312
174313
174314
174315
174316
174317
174318
 
# File 'ext/ctp/ctp.cxx', line 174291

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



174261
174262
174263
174264
174265
174266
174267
174268
174269
174270
174271
174272
174273
174274
174275
174276
174277
174278
174279
174280
174281
174282
174283
174284
174285
174286
174287
174288
 
# File 'ext/ctp/ctp.cxx', line 174261

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



174231
174232
174233
174234
174235
174236
174237
174238
174239
174240
174241
174242
174243
174244
174245
174246
174247
174248
174249
174250
174251
174252
174253
174254
174255
174256
174257
174258
 
# File 'ext/ctp/ctp.cxx', line 174231

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



174201
174202
174203
174204
174205
174206
174207
174208
174209
174210
174211
174212
174213
174214
174215
174216
174217
174218
174219
174220
174221
174222
174223
174224
174225
174226
174227
174228
 
# File 'ext/ctp/ctp.cxx', line 174201

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

#BankNewAccount(*args) ⇒ Object 



175315
175316
175317
175318
175319
175320
175321
175322
175323
175324
175325
175326
175327
175328
175329
175330
175331
175332
175333
175334
175335
175336
175337
175338
175339
175340
175341
175342
 
# File 'ext/ctp/ctp.cxx', line 175315

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

#BankNewAccount=(*args) ⇒ Object 



175285
175286
175287
175288
175289
175290
175291
175292
175293
175294
175295
175296
175297
175298
175299
175300
175301
175302
175303
175304
175305
175306
175307
175308
175309
175310
175311
175312
 
# File 'ext/ctp/ctp.cxx', line 175285

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

#BankSerial(*args) ⇒ Object 



174464
174465
174466
174467
174468
174469
174470
174471
174472
174473
174474
174475
174476
174477
174478
174479
174480
174481
174482
174483
174484
174485
174486
174487
174488
174489
174490
174491
 
# File 'ext/ctp/ctp.cxx', line 174464

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



174434
174435
174436
174437
174438
174439
174440
174441
174442
174443
174444
174445
174446
174447
174448
174449
174450
174451
174452
174453
174454
174455
174456
174457
174458
174459
174460
174461
 
# File 'ext/ctp/ctp.cxx', line 174434

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



174584
174585
174586
174587
174588
174589
174590
174591
174592
174593
174594
174595
174596
174597
174598
174599
174600
174601
174602
174603
174604
174605
174606
174607
174608
174609
174610
174611
 
# File 'ext/ctp/ctp.cxx', line 174584

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



174554
174555
174556
174557
174558
174559
174560
174561
174562
174563
174564
174565
174566
174567
174568
174569
174570
174571
174572
174573
174574
174575
174576
174577
174578
174579
174580
174581
 
# File 'ext/ctp/ctp.cxx', line 174554

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

#BrokerFee(*args) ⇒ Object 



175148
175149
175150
175151
175152
175153
175154
175155
175156
175157
175158
175159
175160
175161
175162
175163
175164
175165
175166
175167
175168
175169
 
# File 'ext/ctp/ctp.cxx', line 175148

SWIGINTERN VALUE
_wrap_CThostFtdcTransferSerialField_BrokerFee_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTransferSerialField *arg1 = (CThostFtdcTransferSerialField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcFutureFeeType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcTransferSerialField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTransferSerialField *","BrokerFee", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTransferSerialField * >(argp1);
  result = (TThostFtdcFutureFeeType) ((arg1)->BrokerFee);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#BrokerFee=(*args) ⇒ Object 



175119
175120
175121
175122
175123
175124
175125
175126
175127
175128
175129
175130
175131
175132
175133
175134
175135
175136
175137
175138
175139
175140
175141
175142
175143
175144
175145
 
# File 'ext/ctp/ctp.cxx', line 175119

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

#BrokerID(*args) ⇒ Object 



174524
174525
174526
174527
174528
174529
174530
174531
174532
174533
174534
174535
174536
174537
174538
174539
174540
174541
174542
174543
174544
174545
174546
174547
174548
174549
174550
174551
 
# File 'ext/ctp/ctp.cxx', line 174524

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



174494
174495
174496
174497
174498
174499
174500
174501
174502
174503
174504
174505
174506
174507
174508
174509
174510
174511
174512
174513
174514
174515
174516
174517
174518
174519
174520
174521
 
# File 'ext/ctp/ctp.cxx', line 174494

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

#CurrencyID(*args) ⇒ Object 



174983
174984
174985
174986
174987
174988
174989
174990
174991
174992
174993
174994
174995
174996
174997
174998
174999
175000
175001
175002
175003
175004
175005
175006
175007
175008
175009
175010
 
# File 'ext/ctp/ctp.cxx', line 174983

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



174953
174954
174955
174956
174957
174958
174959
174960
174961
174962
174963
174964
174965
174966
174967
174968
174969
174970
174971
174972
174973
174974
174975
174976
174977
174978
174979
174980
 
# File 'ext/ctp/ctp.cxx', line 174953

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

#CustFee(*args) ⇒ Object 



175095
175096
175097
175098
175099
175100
175101
175102
175103
175104
175105
175106
175107
175108
175109
175110
175111
175112
175113
175114
175115
175116
 
# File 'ext/ctp/ctp.cxx', line 175095

SWIGINTERN VALUE
_wrap_CThostFtdcTransferSerialField_CustFee_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTransferSerialField *arg1 = (CThostFtdcTransferSerialField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcCustFeeType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcTransferSerialField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTransferSerialField *","CustFee", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTransferSerialField * >(argp1);
  result = (TThostFtdcCustFeeType) ((arg1)->CustFee);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#CustFee=(*args) ⇒ Object 



175066
175067
175068
175069
175070
175071
175072
175073
175074
175075
175076
175077
175078
175079
175080
175081
175082
175083
175084
175085
175086
175087
175088
175089
175090
175091
175092
 
# File 'ext/ctp/ctp.cxx', line 175066

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

#ErrorID(*args) ⇒ Object 



175374
175375
175376
175377
175378
175379
175380
175381
175382
175383
175384
175385
175386
175387
175388
175389
175390
175391
175392
175393
175394
175395
 
# File 'ext/ctp/ctp.cxx', line 175374

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

#ErrorID=(*args) ⇒ Object 



175345
175346
175347
175348
175349
175350
175351
175352
175353
175354
175355
175356
175357
175358
175359
175360
175361
175362
175363
175364
175365
175366
175367
175368
175369
175370
175371
 
# File 'ext/ctp/ctp.cxx', line 175345

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



175428
175429
175430
175431
175432
175433
175434
175435
175436
175437
175438
175439
175440
175441
175442
175443
175444
175445
175446
175447
175448
175449
175450
175451
175452
175453
175454
175455
 
# File 'ext/ctp/ctp.cxx', line 175428

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



175398
175399
175400
175401
175402
175403
175404
175405
175406
175407
175408
175409
175410
175411
175412
175413
175414
175415
175416
175417
175418
175419
175420
175421
175422
175423
175424
175425
 
# File 'ext/ctp/ctp.cxx', line 175398

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

#FutureAccType(*args) ⇒ Object 



174643
174644
174645
174646
174647
174648
174649
174650
174651
174652
174653
174654
174655
174656
174657
174658
174659
174660
174661
174662
174663
174664
 
# File 'ext/ctp/ctp.cxx', line 174643

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

#FutureAccType=(*args) ⇒ Object 



174614
174615
174616
174617
174618
174619
174620
174621
174622
174623
174624
174625
174626
174627
174628
174629
174630
174631
174632
174633
174634
174635
174636
174637
174638
174639
174640
 
# File 'ext/ctp/ctp.cxx', line 174614

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

#FutureSerial(*args) ⇒ Object 



174816
174817
174818
174819
174820
174821
174822
174823
174824
174825
174826
174827
174828
174829
174830
174831
174832
174833
174834
174835
174836
174837
 
# File 'ext/ctp/ctp.cxx', line 174816

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

#FutureSerial=(*args) ⇒ Object 



174787
174788
174789
174790
174791
174792
174793
174794
174795
174796
174797
174798
174799
174800
174801
174802
174803
174804
174805
174806
174807
174808
174809
174810
174811
174812
174813
 
# File 'ext/ctp/ctp.cxx', line 174787

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

#IdCardType(*args) ⇒ Object 



174869
174870
174871
174872
174873
174874
174875
174876
174877
174878
174879
174880
174881
174882
174883
174884
174885
174886
174887
174888
174889
174890
 
# File 'ext/ctp/ctp.cxx', line 174869

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

#IdCardType=(*args) ⇒ Object 



174840
174841
174842
174843
174844
174845
174846
174847
174848
174849
174850
174851
174852
174853
174854
174855
174856
174857
174858
174859
174860
174861
174862
174863
174864
174865
174866
 
# File 'ext/ctp/ctp.cxx', line 174840

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



174923
174924
174925
174926
174927
174928
174929
174930
174931
174932
174933
174934
174935
174936
174937
174938
174939
174940
174941
174942
174943
174944
174945
174946
174947
174948
174949
174950
 
# File 'ext/ctp/ctp.cxx', line 174923

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



174893
174894
174895
174896
174897
174898
174899
174900
174901
174902
174903
174904
174905
174906
174907
174908
174909
174910
174911
174912
174913
174914
174915
174916
174917
174918
174919
174920
 
# File 'ext/ctp/ctp.cxx', line 174893

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

#InvestorID(*args) ⇒ Object 



174757
174758
174759
174760
174761
174762
174763
174764
174765
174766
174767
174768
174769
174770
174771
174772
174773
174774
174775
174776
174777
174778
174779
174780
174781
174782
174783
174784
 
# File 'ext/ctp/ctp.cxx', line 174757

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

#InvestorID=(*args) ⇒ Object 



174727
174728
174729
174730
174731
174732
174733
174734
174735
174736
174737
174738
174739
174740
174741
174742
174743
174744
174745
174746
174747
174748
174749
174750
174751
174752
174753
174754
 
# File 'ext/ctp/ctp.cxx', line 174727

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

#OperatorCode(*args) ⇒ Object 



175255
175256
175257
175258
175259
175260
175261
175262
175263
175264
175265
175266
175267
175268
175269
175270
175271
175272
175273
175274
175275
175276
175277
175278
175279
175280
175281
175282
 
# File 'ext/ctp/ctp.cxx', line 175255

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

#OperatorCode=(*args) ⇒ Object 



175225
175226
175227
175228
175229
175230
175231
175232
175233
175234
175235
175236
175237
175238
175239
175240
175241
175242
175243
175244
175245
175246
175247
175248
175249
175250
175251
175252
 
# File 'ext/ctp/ctp.cxx', line 175225

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

#PlateSerial(*args) ⇒ Object 



173884
173885
173886
173887
173888
173889
173890
173891
173892
173893
173894
173895
173896
173897
173898
173899
173900
173901
173902
173903
173904
173905
 
# File 'ext/ctp/ctp.cxx', line 173884

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

#PlateSerial=(*args) ⇒ Object 



173855
173856
173857
173858
173859
173860
173861
173862
173863
173864
173865
173866
173867
173868
173869
173870
173871
173872
173873
173874
173875
173876
173877
173878
173879
173880
173881
 
# File 'ext/ctp/ctp.cxx', line 173855

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

#SessionID(*args) ⇒ Object 



174177
174178
174179
174180
174181
174182
174183
174184
174185
174186
174187
174188
174189
174190
174191
174192
174193
174194
174195
174196
174197
174198
 
# File 'ext/ctp/ctp.cxx', line 174177

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

#SessionID=(*args) ⇒ Object 



174148
174149
174150
174151
174152
174153
174154
174155
174156
174157
174158
174159
174160
174161
174162
174163
174164
174165
174166
174167
174168
174169
174170
174171
174172
174173
174174
 
# File 'ext/ctp/ctp.cxx', line 174148

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

#TradeAmount(*args) ⇒ Object 



175042
175043
175044
175045
175046
175047
175048
175049
175050
175051
175052
175053
175054
175055
175056
175057
175058
175059
175060
175061
175062
175063
 
# File 'ext/ctp/ctp.cxx', line 175042

SWIGINTERN VALUE
_wrap_CThostFtdcTransferSerialField_TradeAmount_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcTransferSerialField *arg1 = (CThostFtdcTransferSerialField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcTradeAmountType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcTransferSerialField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcTransferSerialField *","TradeAmount", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcTransferSerialField * >(argp1);
  result = (TThostFtdcTradeAmountType) ((arg1)->TradeAmount);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#TradeAmount=(*args) ⇒ Object 



175013
175014
175015
175016
175017
175018
175019
175020
175021
175022
175023
175024
175025
175026
175027
175028
175029
175030
175031
175032
175033
175034
175035
175036
175037
175038
175039
 
# File 'ext/ctp/ctp.cxx', line 175013

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

#TradeCode(*args) ⇒ Object 



174118
174119
174120
174121
174122
174123
174124
174125
174126
174127
174128
174129
174130
174131
174132
174133
174134
174135
174136
174137
174138
174139
174140
174141
174142
174143
174144
174145
 
# File 'ext/ctp/ctp.cxx', line 174118

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



174088
174089
174090
174091
174092
174093
174094
174095
174096
174097
174098
174099
174100
174101
174102
174103
174104
174105
174106
174107
174108
174109
174110
174111
174112
174113
174114
174115
 
# File 'ext/ctp/ctp.cxx', line 174088

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



173938
173939
173940
173941
173942
173943
173944
173945
173946
173947
173948
173949
173950
173951
173952
173953
173954
173955
173956
173957
173958
173959
173960
173961
173962
173963
173964
173965
 
# File 'ext/ctp/ctp.cxx', line 173938

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



173908
173909
173910
173911
173912
173913
173914
173915
173916
173917
173918
173919
173920
173921
173922
173923
173924
173925
173926
173927
173928
173929
173930
173931
173932
173933
173934
173935
 
# File 'ext/ctp/ctp.cxx', line 173908

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



174058
174059
174060
174061
174062
174063
174064
174065
174066
174067
174068
174069
174070
174071
174072
174073
174074
174075
174076
174077
174078
174079
174080
174081
174082
174083
174084
174085
 
# File 'ext/ctp/ctp.cxx', line 174058

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



174028
174029
174030
174031
174032
174033
174034
174035
174036
174037
174038
174039
174040
174041
174042
174043
174044
174045
174046
174047
174048
174049
174050
174051
174052
174053
174054
174055
 
# File 'ext/ctp/ctp.cxx', line 174028

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



173998
173999
174000
174001
174002
174003
174004
174005
174006
174007
174008
174009
174010
174011
174012
174013
174014
174015
174016
174017
174018
174019
174020
174021
174022
174023
174024
174025
 
# File 'ext/ctp/ctp.cxx', line 173998

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



173968
173969
173970
173971
173972
173973
173974
173975
173976
173977
173978
173979
173980
173981
173982
173983
173984
173985
173986
173987
173988
173989
173990
173991
173992
173993
173994
173995
 
# File 'ext/ctp/ctp.cxx', line 173968

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