Class: Ctp::CThostFtdcRspSyncKeyField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



171511
171512
171513
171514
171515
171516
171517
171518
171519
171520
171521
171522
171523
171524
 
# File 'ext/ctp/ctp.cxx', line 171511

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

Instance Method Details

#BankBranchID(*args) ⇒ Object 



170375
170376
170377
170378
170379
170380
170381
170382
170383
170384
170385
170386
170387
170388
170389
170390
170391
170392
170393
170394
170395
170396
170397
170398
170399
170400
170401
170402
 
# File 'ext/ctp/ctp.cxx', line 170375

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



170345
170346
170347
170348
170349
170350
170351
170352
170353
170354
170355
170356
170357
170358
170359
170360
170361
170362
170363
170364
170365
170366
170367
170368
170369
170370
170371
170372
 
# File 'ext/ctp/ctp.cxx', line 170345

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



170315
170316
170317
170318
170319
170320
170321
170322
170323
170324
170325
170326
170327
170328
170329
170330
170331
170332
170333
170334
170335
170336
170337
170338
170339
170340
170341
170342
 
# File 'ext/ctp/ctp.cxx', line 170315

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



170285
170286
170287
170288
170289
170290
170291
170292
170293
170294
170295
170296
170297
170298
170299
170300
170301
170302
170303
170304
170305
170306
170307
170308
170309
170310
170311
170312
 
# File 'ext/ctp/ctp.cxx', line 170285

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

#BankSerial(*args) ⇒ Object 



170675
170676
170677
170678
170679
170680
170681
170682
170683
170684
170685
170686
170687
170688
170689
170690
170691
170692
170693
170694
170695
170696
170697
170698
170699
170700
170701
170702
 
# File 'ext/ctp/ctp.cxx', line 170675

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



170645
170646
170647
170648
170649
170650
170651
170652
170653
170654
170655
170656
170657
170658
170659
170660
170661
170662
170663
170664
170665
170666
170667
170668
170669
170670
170671
170672
 
# File 'ext/ctp/ctp.cxx', line 170645

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



170495
170496
170497
170498
170499
170500
170501
170502
170503
170504
170505
170506
170507
170508
170509
170510
170511
170512
170513
170514
170515
170516
170517
170518
170519
170520
170521
170522
 
# File 'ext/ctp/ctp.cxx', line 170495

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



170465
170466
170467
170468
170469
170470
170471
170472
170473
170474
170475
170476
170477
170478
170479
170480
170481
170482
170483
170484
170485
170486
170487
170488
170489
170490
170491
170492
 
# File 'ext/ctp/ctp.cxx', line 170465

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



170435
170436
170437
170438
170439
170440
170441
170442
170443
170444
170445
170446
170447
170448
170449
170450
170451
170452
170453
170454
170455
170456
170457
170458
170459
170460
170461
170462
 
# File 'ext/ctp/ctp.cxx', line 170435

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



170405
170406
170407
170408
170409
170410
170411
170412
170413
170414
170415
170416
170417
170418
170419
170420
170421
170422
170423
170424
170425
170426
170427
170428
170429
170430
170431
170432
 
# File 'ext/ctp/ctp.cxx', line 170405

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



171187
171188
171189
171190
171191
171192
171193
171194
171195
171196
171197
171198
171199
171200
171201
171202
171203
171204
171205
171206
171207
171208
171209
171210
171211
171212
171213
171214
 
# File 'ext/ctp/ctp.cxx', line 171187

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



171157
171158
171159
171160
171161
171162
171163
171164
171165
171166
171167
171168
171169
171170
171171
171172
171173
171174
171175
171176
171177
171178
171179
171180
171181
171182
171183
171184
 
# File 'ext/ctp/ctp.cxx', line 171157

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

#DeviceID(*args) ⇒ Object 



171127
171128
171129
171130
171131
171132
171133
171134
171135
171136
171137
171138
171139
171140
171141
171142
171143
171144
171145
171146
171147
171148
171149
171150
171151
171152
171153
171154
 
# File 'ext/ctp/ctp.cxx', line 171127

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



171097
171098
171099
171100
171101
171102
171103
171104
171105
171106
171107
171108
171109
171110
171111
171112
171113
171114
171115
171116
171117
171118
171119
171120
171121
171122
171123
171124
 
# File 'ext/ctp/ctp.cxx', line 171097

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

#ErrorID(*args) ⇒ Object 



171412
171413
171414
171415
171416
171417
171418
171419
171420
171421
171422
171423
171424
171425
171426
171427
171428
171429
171430
171431
171432
171433
 
# File 'ext/ctp/ctp.cxx', line 171412

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

#ErrorID=(*args) ⇒ Object 



171383
171384
171385
171386
171387
171388
171389
171390
171391
171392
171393
171394
171395
171396
171397
171398
171399
171400
171401
171402
171403
171404
171405
171406
171407
171408
171409
 
# File 'ext/ctp/ctp.cxx', line 171383

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



171466
171467
171468
171469
171470
171471
171472
171473
171474
171475
171476
171477
171478
171479
171480
171481
171482
171483
171484
171485
171486
171487
171488
171489
171490
171491
171492
171493
 
# File 'ext/ctp/ctp.cxx', line 171466

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



171436
171437
171438
171439
171440
171441
171442
171443
171444
171445
171446
171447
171448
171449
171450
171451
171452
171453
171454
171455
171456
171457
171458
171459
171460
171461
171462
171463
 
# File 'ext/ctp/ctp.cxx', line 171436

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

#InstallID(*args) ⇒ Object 



170953
170954
170955
170956
170957
170958
170959
170960
170961
170962
170963
170964
170965
170966
170967
170968
170969
170970
170971
170972
170973
170974
 
# File 'ext/ctp/ctp.cxx', line 170953

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

#InstallID=(*args) ⇒ Object 



170924
170925
170926
170927
170928
170929
170930
170931
170932
170933
170934
170935
170936
170937
170938
170939
170940
170941
170942
170943
170944
170945
170946
170947
170948
170949
170950
 
# File 'ext/ctp/ctp.cxx', line 170924

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



170847
170848
170849
170850
170851
170852
170853
170854
170855
170856
170857
170858
170859
170860
170861
170862
170863
170864
170865
170866
170867
170868
 
# File 'ext/ctp/ctp.cxx', line 170847

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

#LastFragment=(*args) ⇒ Object 



170818
170819
170820
170821
170822
170823
170824
170825
170826
170827
170828
170829
170830
170831
170832
170833
170834
170835
170836
170837
170838
170839
170840
170841
170842
170843
170844
 
# File 'ext/ctp/ctp.cxx', line 170818

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

#Message(*args) ⇒ Object 



171067
171068
171069
171070
171071
171072
171073
171074
171075
171076
171077
171078
171079
171080
171081
171082
171083
171084
171085
171086
171087
171088
171089
171090
171091
171092
171093
171094
 
# File 'ext/ctp/ctp.cxx', line 171067

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

#Message=(*args) ⇒ Object 



171037
171038
171039
171040
171041
171042
171043
171044
171045
171046
171047
171048
171049
171050
171051
171052
171053
171054
171055
171056
171057
171058
171059
171060
171061
171062
171063
171064
 
# File 'ext/ctp/ctp.cxx', line 171037

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

#OperNo(*args) ⇒ Object 



171247
171248
171249
171250
171251
171252
171253
171254
171255
171256
171257
171258
171259
171260
171261
171262
171263
171264
171265
171266
171267
171268
171269
171270
171271
171272
171273
171274
 
# File 'ext/ctp/ctp.cxx', line 171247

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



171217
171218
171219
171220
171221
171222
171223
171224
171225
171226
171227
171228
171229
171230
171231
171232
171233
171234
171235
171236
171237
171238
171239
171240
171241
171242
171243
171244
 
# File 'ext/ctp/ctp.cxx', line 171217

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

#PlateSerial(*args) ⇒ Object 



170794
170795
170796
170797
170798
170799
170800
170801
170802
170803
170804
170805
170806
170807
170808
170809
170810
170811
170812
170813
170814
170815
 
# File 'ext/ctp/ctp.cxx', line 170794

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

#PlateSerial=(*args) ⇒ Object 



170765
170766
170767
170768
170769
170770
170771
170772
170773
170774
170775
170776
170777
170778
170779
170780
170781
170782
170783
170784
170785
170786
170787
170788
170789
170790
170791
 
# File 'ext/ctp/ctp.cxx', line 170765

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

#RequestID(*args) ⇒ Object 



171306
171307
171308
171309
171310
171311
171312
171313
171314
171315
171316
171317
171318
171319
171320
171321
171322
171323
171324
171325
171326
171327
 
# File 'ext/ctp/ctp.cxx', line 171306

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

#RequestID=(*args) ⇒ Object 



171277
171278
171279
171280
171281
171282
171283
171284
171285
171286
171287
171288
171289
171290
171291
171292
171293
171294
171295
171296
171297
171298
171299
171300
171301
171302
171303
 
# File 'ext/ctp/ctp.cxx', line 171277

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

#SessionID(*args) ⇒ Object 



170900
170901
170902
170903
170904
170905
170906
170907
170908
170909
170910
170911
170912
170913
170914
170915
170916
170917
170918
170919
170920
170921
 
# File 'ext/ctp/ctp.cxx', line 170900

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

#SessionID=(*args) ⇒ Object 



170871
170872
170873
170874
170875
170876
170877
170878
170879
170880
170881
170882
170883
170884
170885
170886
170887
170888
170889
170890
170891
170892
170893
170894
170895
170896
170897
 
# File 'ext/ctp/ctp.cxx', line 170871

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

#TID(*args) ⇒ Object 



171359
171360
171361
171362
171363
171364
171365
171366
171367
171368
171369
171370
171371
171372
171373
171374
171375
171376
171377
171378
171379
171380
 
# File 'ext/ctp/ctp.cxx', line 171359

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

#TID=(*args) ⇒ Object 



171330
171331
171332
171333
171334
171335
171336
171337
171338
171339
171340
171341
171342
171343
171344
171345
171346
171347
171348
171349
171350
171351
171352
171353
171354
171355
171356
 
# File 'ext/ctp/ctp.cxx', line 171330

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



170255
170256
170257
170258
170259
170260
170261
170262
170263
170264
170265
170266
170267
170268
170269
170270
170271
170272
170273
170274
170275
170276
170277
170278
170279
170280
170281
170282
 
# File 'ext/ctp/ctp.cxx', line 170255

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



170225
170226
170227
170228
170229
170230
170231
170232
170233
170234
170235
170236
170237
170238
170239
170240
170241
170242
170243
170244
170245
170246
170247
170248
170249
170250
170251
170252
 
# File 'ext/ctp/ctp.cxx', line 170225

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



170555
170556
170557
170558
170559
170560
170561
170562
170563
170564
170565
170566
170567
170568
170569
170570
170571
170572
170573
170574
170575
170576
170577
170578
170579
170580
170581
170582
 
# File 'ext/ctp/ctp.cxx', line 170555

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



170525
170526
170527
170528
170529
170530
170531
170532
170533
170534
170535
170536
170537
170538
170539
170540
170541
170542
170543
170544
170545
170546
170547
170548
170549
170550
170551
170552
 
# File 'ext/ctp/ctp.cxx', line 170525

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



170615
170616
170617
170618
170619
170620
170621
170622
170623
170624
170625
170626
170627
170628
170629
170630
170631
170632
170633
170634
170635
170636
170637
170638
170639
170640
170641
170642
 
# File 'ext/ctp/ctp.cxx', line 170615

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



170585
170586
170587
170588
170589
170590
170591
170592
170593
170594
170595
170596
170597
170598
170599
170600
170601
170602
170603
170604
170605
170606
170607
170608
170609
170610
170611
170612
 
# File 'ext/ctp/ctp.cxx', line 170585

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



170735
170736
170737
170738
170739
170740
170741
170742
170743
170744
170745
170746
170747
170748
170749
170750
170751
170752
170753
170754
170755
170756
170757
170758
170759
170760
170761
170762
 
# File 'ext/ctp/ctp.cxx', line 170735

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



170705
170706
170707
170708
170709
170710
170711
170712
170713
170714
170715
170716
170717
170718
170719
170720
170721
170722
170723
170724
170725
170726
170727
170728
170729
170730
170731
170732
 
# File 'ext/ctp/ctp.cxx', line 170705

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



171007
171008
171009
171010
171011
171012
171013
171014
171015
171016
171017
171018
171019
171020
171021
171022
171023
171024
171025
171026
171027
171028
171029
171030
171031
171032
171033
171034
 
# File 'ext/ctp/ctp.cxx', line 171007

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



170977
170978
170979
170980
170981
170982
170983
170984
170985
170986
170987
170988
170989
170990
170991
170992
170993
170994
170995
170996
170997
170998
170999
171000
171001
171002
171003
171004
 
# File 'ext/ctp/ctp.cxx', line 170977

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