Class: Ctp::CThostFtdcRspQueryTradeResultBySerialField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



165695
165696
165697
165698
165699
165700
165701
165702
165703
165704
165705
165706
165707
165708
 
# File 'ext/ctp/ctp.cxx', line 165695

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

Instance Method Details

#AccountID(*args) ⇒ Object 



165417
165418
165419
165420
165421
165422
165423
165424
165425
165426
165427
165428
165429
165430
165431
165432
165433
165434
165435
165436
165437
165438
165439
165440
165441
165442
165443
165444
 
# File 'ext/ctp/ctp.cxx', line 165417

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



165387
165388
165389
165390
165391
165392
165393
165394
165395
165396
165397
165398
165399
165400
165401
165402
165403
165404
165405
165406
165407
165408
165409
165410
165411
165412
165413
165414
 
# File 'ext/ctp/ctp.cxx', line 165387

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

#BankAccount(*args) ⇒ Object 



165297
165298
165299
165300
165301
165302
165303
165304
165305
165306
165307
165308
165309
165310
165311
165312
165313
165314
165315
165316
165317
165318
165319
165320
165321
165322
165323
165324
 
# File 'ext/ctp/ctp.cxx', line 165297

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



165267
165268
165269
165270
165271
165272
165273
165274
165275
165276
165277
165278
165279
165280
165281
165282
165283
165284
165285
165286
165287
165288
165289
165290
165291
165292
165293
165294
 
# File 'ext/ctp/ctp.cxx', line 165267

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

#BankBranchID(*args) ⇒ Object 



164319
164320
164321
164322
164323
164324
164325
164326
164327
164328
164329
164330
164331
164332
164333
164334
164335
164336
164337
164338
164339
164340
164341
164342
164343
164344
164345
164346
 
# File 'ext/ctp/ctp.cxx', line 164319

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



164289
164290
164291
164292
164293
164294
164295
164296
164297
164298
164299
164300
164301
164302
164303
164304
164305
164306
164307
164308
164309
164310
164311
164312
164313
164314
164315
164316
 
# File 'ext/ctp/ctp.cxx', line 164289

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



164259
164260
164261
164262
164263
164264
164265
164266
164267
164268
164269
164270
164271
164272
164273
164274
164275
164276
164277
164278
164279
164280
164281
164282
164283
164284
164285
164286
 
# File 'ext/ctp/ctp.cxx', line 164259

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



164229
164230
164231
164232
164233
164234
164235
164236
164237
164238
164239
164240
164241
164242
164243
164244
164245
164246
164247
164248
164249
164250
164251
164252
164253
164254
164255
164256
 
# File 'ext/ctp/ctp.cxx', line 164229

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

#BankPassWord(*args) ⇒ Object 



165357
165358
165359
165360
165361
165362
165363
165364
165365
165366
165367
165368
165369
165370
165371
165372
165373
165374
165375
165376
165377
165378
165379
165380
165381
165382
165383
165384
 
# File 'ext/ctp/ctp.cxx', line 165357

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

#BankPassWord=(*args) ⇒ Object 



165327
165328
165329
165330
165331
165332
165333
165334
165335
165336
165337
165338
165339
165340
165341
165342
165343
165344
165345
165346
165347
165348
165349
165350
165351
165352
165353
165354
 
# File 'ext/ctp/ctp.cxx', line 165327

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

#BankSerial(*args) ⇒ Object 



164619
164620
164621
164622
164623
164624
164625
164626
164627
164628
164629
164630
164631
164632
164633
164634
164635
164636
164637
164638
164639
164640
164641
164642
164643
164644
164645
164646
 
# File 'ext/ctp/ctp.cxx', line 164619

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



164589
164590
164591
164592
164593
164594
164595
164596
164597
164598
164599
164600
164601
164602
164603
164604
164605
164606
164607
164608
164609
164610
164611
164612
164613
164614
164615
164616
 
# File 'ext/ctp/ctp.cxx', line 164589

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



164439
164440
164441
164442
164443
164444
164445
164446
164447
164448
164449
164450
164451
164452
164453
164454
164455
164456
164457
164458
164459
164460
164461
164462
164463
164464
164465
164466
 
# File 'ext/ctp/ctp.cxx', line 164439

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



164409
164410
164411
164412
164413
164414
164415
164416
164417
164418
164419
164420
164421
164422
164423
164424
164425
164426
164427
164428
164429
164430
164431
164432
164433
164434
164435
164436
 
# File 'ext/ctp/ctp.cxx', line 164409

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



164379
164380
164381
164382
164383
164384
164385
164386
164387
164388
164389
164390
164391
164392
164393
164394
164395
164396
164397
164398
164399
164400
164401
164402
164403
164404
164405
164406
 
# File 'ext/ctp/ctp.cxx', line 164379

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



164349
164350
164351
164352
164353
164354
164355
164356
164357
164358
164359
164360
164361
164362
164363
164364
164365
164366
164367
164368
164369
164370
164371
164372
164373
164374
164375
164376
 
# File 'ext/ctp/ctp.cxx', line 164349

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



165537
165538
165539
165540
165541
165542
165543
165544
165545
165546
165547
165548
165549
165550
165551
165552
165553
165554
165555
165556
165557
165558
165559
165560
165561
165562
165563
165564
 
# File 'ext/ctp/ctp.cxx', line 165537

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



165507
165508
165509
165510
165511
165512
165513
165514
165515
165516
165517
165518
165519
165520
165521
165522
165523
165524
165525
165526
165527
165528
165529
165530
165531
165532
165533
165534
 
# File 'ext/ctp/ctp.cxx', line 165507

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

#Digest(*args) ⇒ Object 



165650
165651
165652
165653
165654
165655
165656
165657
165658
165659
165660
165661
165662
165663
165664
165665
165666
165667
165668
165669
165670
165671
165672
165673
165674
165675
165676
165677
 
# File 'ext/ctp/ctp.cxx', line 165650

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

#Digest=(*args) ⇒ Object 



165620
165621
165622
165623
165624
165625
165626
165627
165628
165629
165630
165631
165632
165633
165634
165635
165636
165637
165638
165639
165640
165641
165642
165643
165644
165645
165646
165647
 
# File 'ext/ctp/ctp.cxx', line 165620

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

#ErrorID(*args) ⇒ Object 



164897
164898
164899
164900
164901
164902
164903
164904
164905
164906
164907
164908
164909
164910
164911
164912
164913
164914
164915
164916
164917
164918
 
# File 'ext/ctp/ctp.cxx', line 164897

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

#ErrorID=(*args) ⇒ Object 



164868
164869
164870
164871
164872
164873
164874
164875
164876
164877
164878
164879
164880
164881
164882
164883
164884
164885
164886
164887
164888
164889
164890
164891
164892
164893
164894
 
# File 'ext/ctp/ctp.cxx', line 164868

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



164951
164952
164953
164954
164955
164956
164957
164958
164959
164960
164961
164962
164963
164964
164965
164966
164967
164968
164969
164970
164971
164972
164973
164974
164975
164976
164977
164978
 
# File 'ext/ctp/ctp.cxx', line 164951

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



164921
164922
164923
164924
164925
164926
164927
164928
164929
164930
164931
164932
164933
164934
164935
164936
164937
164938
164939
164940
164941
164942
164943
164944
164945
164946
164947
164948
 
# File 'ext/ctp/ctp.cxx', line 164921

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

#LastFragment(*args) ⇒ Object 



164791
164792
164793
164794
164795
164796
164797
164798
164799
164800
164801
164802
164803
164804
164805
164806
164807
164808
164809
164810
164811
164812
 
# File 'ext/ctp/ctp.cxx', line 164791

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

#LastFragment=(*args) ⇒ Object 



164762
164763
164764
164765
164766
164767
164768
164769
164770
164771
164772
164773
164774
164775
164776
164777
164778
164779
164780
164781
164782
164783
164784
164785
164786
164787
164788
 
# File 'ext/ctp/ctp.cxx', line 164762

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

#OriginDescrInfoForReturnCode(*args) ⇒ Object 



165237
165238
165239
165240
165241
165242
165243
165244
165245
165246
165247
165248
165249
165250
165251
165252
165253
165254
165255
165256
165257
165258
165259
165260
165261
165262
165263
165264
 
# File 'ext/ctp/ctp.cxx', line 165237

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

#OriginDescrInfoForReturnCode=(*args) ⇒ Object 



165207
165208
165209
165210
165211
165212
165213
165214
165215
165216
165217
165218
165219
165220
165221
165222
165223
165224
165225
165226
165227
165228
165229
165230
165231
165232
165233
165234
 
# File 'ext/ctp/ctp.cxx', line 165207

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

#OriginReturnCode(*args) ⇒ Object 



165177
165178
165179
165180
165181
165182
165183
165184
165185
165186
165187
165188
165189
165190
165191
165192
165193
165194
165195
165196
165197
165198
165199
165200
165201
165202
165203
165204
 
# File 'ext/ctp/ctp.cxx', line 165177

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

#OriginReturnCode=(*args) ⇒ Object 



165147
165148
165149
165150
165151
165152
165153
165154
165155
165156
165157
165158
165159
165160
165161
165162
165163
165164
165165
165166
165167
165168
165169
165170
165171
165172
165173
165174
 
# File 'ext/ctp/ctp.cxx', line 165147

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

#Password(*args) ⇒ Object 



165477
165478
165479
165480
165481
165482
165483
165484
165485
165486
165487
165488
165489
165490
165491
165492
165493
165494
165495
165496
165497
165498
165499
165500
165501
165502
165503
165504
 
# File 'ext/ctp/ctp.cxx', line 165477

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

#Password=(*args) ⇒ Object 



165447
165448
165449
165450
165451
165452
165453
165454
165455
165456
165457
165458
165459
165460
165461
165462
165463
165464
165465
165466
165467
165468
165469
165470
165471
165472
165473
165474
 
# File 'ext/ctp/ctp.cxx', line 165447

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

#PlateSerial(*args) ⇒ Object 



164738
164739
164740
164741
164742
164743
164744
164745
164746
164747
164748
164749
164750
164751
164752
164753
164754
164755
164756
164757
164758
164759
 
# File 'ext/ctp/ctp.cxx', line 164738

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

#PlateSerial=(*args) ⇒ Object 



164709
164710
164711
164712
164713
164714
164715
164716
164717
164718
164719
164720
164721
164722
164723
164724
164725
164726
164727
164728
164729
164730
164731
164732
164733
164734
164735
 
# File 'ext/ctp/ctp.cxx', line 164709

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

#Reference(*args) ⇒ Object 



165010
165011
165012
165013
165014
165015
165016
165017
165018
165019
165020
165021
165022
165023
165024
165025
165026
165027
165028
165029
165030
165031
 
# File 'ext/ctp/ctp.cxx', line 165010

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

#Reference=(*args) ⇒ Object 



164981
164982
164983
164984
164985
164986
164987
164988
164989
164990
164991
164992
164993
164994
164995
164996
164997
164998
164999
165000
165001
165002
165003
165004
165005
165006
165007
 
# File 'ext/ctp/ctp.cxx', line 164981

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

#RefrenceIssure(*args) ⇒ Object 



165117
165118
165119
165120
165121
165122
165123
165124
165125
165126
165127
165128
165129
165130
165131
165132
165133
165134
165135
165136
165137
165138
165139
165140
165141
165142
165143
165144
 
# File 'ext/ctp/ctp.cxx', line 165117

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

#RefrenceIssure=(*args) ⇒ Object 



165087
165088
165089
165090
165091
165092
165093
165094
165095
165096
165097
165098
165099
165100
165101
165102
165103
165104
165105
165106
165107
165108
165109
165110
165111
165112
165113
165114
 
# File 'ext/ctp/ctp.cxx', line 165087

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

#RefrenceIssureType(*args) ⇒ Object 



165063
165064
165065
165066
165067
165068
165069
165070
165071
165072
165073
165074
165075
165076
165077
165078
165079
165080
165081
165082
165083
165084
 
# File 'ext/ctp/ctp.cxx', line 165063

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

#RefrenceIssureType=(*args) ⇒ Object 



165034
165035
165036
165037
165038
165039
165040
165041
165042
165043
165044
165045
165046
165047
165048
165049
165050
165051
165052
165053
165054
165055
165056
165057
165058
165059
165060
 
# File 'ext/ctp/ctp.cxx', line 165034

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

#SessionID(*args) ⇒ Object 



164844
164845
164846
164847
164848
164849
164850
164851
164852
164853
164854
164855
164856
164857
164858
164859
164860
164861
164862
164863
164864
164865
 
# File 'ext/ctp/ctp.cxx', line 164844

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

#SessionID=(*args) ⇒ Object 



164815
164816
164817
164818
164819
164820
164821
164822
164823
164824
164825
164826
164827
164828
164829
164830
164831
164832
164833
164834
164835
164836
164837
164838
164839
164840
164841
 
# File 'ext/ctp/ctp.cxx', line 164815

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



165596
165597
165598
165599
165600
165601
165602
165603
165604
165605
165606
165607
165608
165609
165610
165611
165612
165613
165614
165615
165616
165617
 
# File 'ext/ctp/ctp.cxx', line 165596

SWIGINTERN VALUE
_wrap_CThostFtdcRspQueryTradeResultBySerialField_TradeAmount_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcRspQueryTradeResultBySerialField *arg1 = (CThostFtdcRspQueryTradeResultBySerialField *) 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_CThostFtdcRspQueryTradeResultBySerialField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcRspQueryTradeResultBySerialField *","TradeAmount", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcRspQueryTradeResultBySerialField * >(argp1);
  result = (TThostFtdcTradeAmountType) ((arg1)->TradeAmount);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#TradeAmount=(*args) ⇒ Object 



165567
165568
165569
165570
165571
165572
165573
165574
165575
165576
165577
165578
165579
165580
165581
165582
165583
165584
165585
165586
165587
165588
165589
165590
165591
165592
165593
 
# File 'ext/ctp/ctp.cxx', line 165567

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



164199
164200
164201
164202
164203
164204
164205
164206
164207
164208
164209
164210
164211
164212
164213
164214
164215
164216
164217
164218
164219
164220
164221
164222
164223
164224
164225
164226
 
# File 'ext/ctp/ctp.cxx', line 164199

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



164169
164170
164171
164172
164173
164174
164175
164176
164177
164178
164179
164180
164181
164182
164183
164184
164185
164186
164187
164188
164189
164190
164191
164192
164193
164194
164195
164196
 
# File 'ext/ctp/ctp.cxx', line 164169

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



164499
164500
164501
164502
164503
164504
164505
164506
164507
164508
164509
164510
164511
164512
164513
164514
164515
164516
164517
164518
164519
164520
164521
164522
164523
164524
164525
164526
 
# File 'ext/ctp/ctp.cxx', line 164499

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



164469
164470
164471
164472
164473
164474
164475
164476
164477
164478
164479
164480
164481
164482
164483
164484
164485
164486
164487
164488
164489
164490
164491
164492
164493
164494
164495
164496
 
# File 'ext/ctp/ctp.cxx', line 164469

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



164559
164560
164561
164562
164563
164564
164565
164566
164567
164568
164569
164570
164571
164572
164573
164574
164575
164576
164577
164578
164579
164580
164581
164582
164583
164584
164585
164586
 
# File 'ext/ctp/ctp.cxx', line 164559

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



164529
164530
164531
164532
164533
164534
164535
164536
164537
164538
164539
164540
164541
164542
164543
164544
164545
164546
164547
164548
164549
164550
164551
164552
164553
164554
164555
164556
 
# File 'ext/ctp/ctp.cxx', line 164529

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



164679
164680
164681
164682
164683
164684
164685
164686
164687
164688
164689
164690
164691
164692
164693
164694
164695
164696
164697
164698
164699
164700
164701
164702
164703
164704
164705
164706
 
# File 'ext/ctp/ctp.cxx', line 164679

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



164649
164650
164651
164652
164653
164654
164655
164656
164657
164658
164659
164660
164661
164662
164663
164664
164665
164666
164667
164668
164669
164670
164671
164672
164673
164674
164675
164676
 
# File 'ext/ctp/ctp.cxx', line 164649

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