Class: Ctp::CThostFtdcTraderOfferField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



27724
27725
27726
27727
27728
27729
27730
27731
27732
27733
27734
27735
27736
27737
 
# File 'ext/ctp/ctp.cxx', line 27724

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

Instance Method Details

#BrokerID(*args) ⇒ Object 



27559
27560
27561
27562
27563
27564
27565
27566
27567
27568
27569
27570
27571
27572
27573
27574
27575
27576
27577
27578
27579
27580
27581
27582
27583
27584
27585
27586
 
# File 'ext/ctp/ctp.cxx', line 27559

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



27529
27530
27531
27532
27533
27534
27535
27536
27537
27538
27539
27540
27541
27542
27543
27544
27545
27546
27547
27548
27549
27550
27551
27552
27553
27554
27555
27556
 
# File 'ext/ctp/ctp.cxx', line 27529

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

#ConnectDate(*args) ⇒ Object 



27259
27260
27261
27262
27263
27264
27265
27266
27267
27268
27269
27270
27271
27272
27273
27274
27275
27276
27277
27278
27279
27280
27281
27282
27283
27284
27285
27286
 
# File 'ext/ctp/ctp.cxx', line 27259

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

#ConnectDate=(*args) ⇒ Object 



27229
27230
27231
27232
27233
27234
27235
27236
27237
27238
27239
27240
27241
27242
27243
27244
27245
27246
27247
27248
27249
27250
27251
27252
27253
27254
27255
27256
 
# File 'ext/ctp/ctp.cxx', line 27229

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

#ConnectRequestDate(*args) ⇒ Object 



27019
27020
27021
27022
27023
27024
27025
27026
27027
27028
27029
27030
27031
27032
27033
27034
27035
27036
27037
27038
27039
27040
27041
27042
27043
27044
27045
27046
 
# File 'ext/ctp/ctp.cxx', line 27019

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

#ConnectRequestDate=(*args) ⇒ Object 



26989
26990
26991
26992
26993
26994
26995
26996
26997
26998
26999
27000
27001
27002
27003
27004
27005
27006
27007
27008
27009
27010
27011
27012
27013
27014
27015
27016
 
# File 'ext/ctp/ctp.cxx', line 26989

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

#ConnectRequestTime(*args) ⇒ Object 



27079
27080
27081
27082
27083
27084
27085
27086
27087
27088
27089
27090
27091
27092
27093
27094
27095
27096
27097
27098
27099
27100
27101
27102
27103
27104
27105
27106
 
# File 'ext/ctp/ctp.cxx', line 27079

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

#ConnectRequestTime=(*args) ⇒ Object 



27049
27050
27051
27052
27053
27054
27055
27056
27057
27058
27059
27060
27061
27062
27063
27064
27065
27066
27067
27068
27069
27070
27071
27072
27073
27074
27075
27076
 
# File 'ext/ctp/ctp.cxx', line 27049

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

#ConnectTime(*args) ⇒ Object 



27319
27320
27321
27322
27323
27324
27325
27326
27327
27328
27329
27330
27331
27332
27333
27334
27335
27336
27337
27338
27339
27340
27341
27342
27343
27344
27345
27346
 
# File 'ext/ctp/ctp.cxx', line 27319

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

#ConnectTime=(*args) ⇒ Object 



27289
27290
27291
27292
27293
27294
27295
27296
27297
27298
27299
27300
27301
27302
27303
27304
27305
27306
27307
27308
27309
27310
27311
27312
27313
27314
27315
27316
 
# File 'ext/ctp/ctp.cxx', line 27289

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

#ExchangeID(*args) ⇒ Object 



26613
26614
26615
26616
26617
26618
26619
26620
26621
26622
26623
26624
26625
26626
26627
26628
26629
26630
26631
26632
26633
26634
26635
26636
26637
26638
26639
26640
 
# File 'ext/ctp/ctp.cxx', line 26613

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

#ExchangeID=(*args) ⇒ Object 



26583
26584
26585
26586
26587
26588
26589
26590
26591
26592
26593
26594
26595
26596
26597
26598
26599
26600
26601
26602
26603
26604
26605
26606
26607
26608
26609
26610
 
# File 'ext/ctp/ctp.cxx', line 26583

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

#InstallID(*args) ⇒ Object 



26852
26853
26854
26855
26856
26857
26858
26859
26860
26861
26862
26863
26864
26865
26866
26867
26868
26869
26870
26871
26872
26873
 
# File 'ext/ctp/ctp.cxx', line 26852

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

#InstallID=(*args) ⇒ Object 



26823
26824
26825
26826
26827
26828
26829
26830
26831
26832
26833
26834
26835
26836
26837
26838
26839
26840
26841
26842
26843
26844
26845
26846
26847
26848
26849
 
# File 'ext/ctp/ctp.cxx', line 26823

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

#LastReportDate(*args) ⇒ Object 



27139
27140
27141
27142
27143
27144
27145
27146
27147
27148
27149
27150
27151
27152
27153
27154
27155
27156
27157
27158
27159
27160
27161
27162
27163
27164
27165
27166
 
# File 'ext/ctp/ctp.cxx', line 27139

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

#LastReportDate=(*args) ⇒ Object 



27109
27110
27111
27112
27113
27114
27115
27116
27117
27118
27119
27120
27121
27122
27123
27124
27125
27126
27127
27128
27129
27130
27131
27132
27133
27134
27135
27136
 
# File 'ext/ctp/ctp.cxx', line 27109

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

#LastReportTime(*args) ⇒ Object 



27199
27200
27201
27202
27203
27204
27205
27206
27207
27208
27209
27210
27211
27212
27213
27214
27215
27216
27217
27218
27219
27220
27221
27222
27223
27224
27225
27226
 
# File 'ext/ctp/ctp.cxx', line 27199

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

#LastReportTime=(*args) ⇒ Object 



27169
27170
27171
27172
27173
27174
27175
27176
27177
27178
27179
27180
27181
27182
27183
27184
27185
27186
27187
27188
27189
27190
27191
27192
27193
27194
27195
27196
 
# File 'ext/ctp/ctp.cxx', line 27169

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

#MaxOrderMessageReference(*args) ⇒ Object 



27679
27680
27681
27682
27683
27684
27685
27686
27687
27688
27689
27690
27691
27692
27693
27694
27695
27696
27697
27698
27699
27700
27701
27702
27703
27704
27705
27706
 
# File 'ext/ctp/ctp.cxx', line 27679

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

#MaxOrderMessageReference=(*args) ⇒ Object 



27649
27650
27651
27652
27653
27654
27655
27656
27657
27658
27659
27660
27661
27662
27663
27664
27665
27666
27667
27668
27669
27670
27671
27672
27673
27674
27675
27676
 
# File 'ext/ctp/ctp.cxx', line 27649

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

#MaxTradeID(*args) ⇒ Object 



27619
27620
27621
27622
27623
27624
27625
27626
27627
27628
27629
27630
27631
27632
27633
27634
27635
27636
27637
27638
27639
27640
27641
27642
27643
27644
27645
27646
 
# File 'ext/ctp/ctp.cxx', line 27619

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

#MaxTradeID=(*args) ⇒ Object 



27589
27590
27591
27592
27593
27594
27595
27596
27597
27598
27599
27600
27601
27602
27603
27604
27605
27606
27607
27608
27609
27610
27611
27612
27613
27614
27615
27616
 
# File 'ext/ctp/ctp.cxx', line 27589

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

#OrderLocalID(*args) ⇒ Object 



26906
26907
26908
26909
26910
26911
26912
26913
26914
26915
26916
26917
26918
26919
26920
26921
26922
26923
26924
26925
26926
26927
26928
26929
26930
26931
26932
26933
 
# File 'ext/ctp/ctp.cxx', line 26906

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

#OrderLocalID=(*args) ⇒ Object 



26876
26877
26878
26879
26880
26881
26882
26883
26884
26885
26886
26887
26888
26889
26890
26891
26892
26893
26894
26895
26896
26897
26898
26899
26900
26901
26902
26903
 
# File 'ext/ctp/ctp.cxx', line 26876

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

#ParticipantID(*args) ⇒ Object 



26733
26734
26735
26736
26737
26738
26739
26740
26741
26742
26743
26744
26745
26746
26747
26748
26749
26750
26751
26752
26753
26754
26755
26756
26757
26758
26759
26760
 
# File 'ext/ctp/ctp.cxx', line 26733

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

#ParticipantID=(*args) ⇒ Object 



26703
26704
26705
26706
26707
26708
26709
26710
26711
26712
26713
26714
26715
26716
26717
26718
26719
26720
26721
26722
26723
26724
26725
26726
26727
26728
26729
26730
 
# File 'ext/ctp/ctp.cxx', line 26703

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

#Password(*args) ⇒ Object 



26793
26794
26795
26796
26797
26798
26799
26800
26801
26802
26803
26804
26805
26806
26807
26808
26809
26810
26811
26812
26813
26814
26815
26816
26817
26818
26819
26820
 
# File 'ext/ctp/ctp.cxx', line 26793

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



26763
26764
26765
26766
26767
26768
26769
26770
26771
26772
26773
26774
26775
26776
26777
26778
26779
26780
26781
26782
26783
26784
26785
26786
26787
26788
26789
26790
 
# File 'ext/ctp/ctp.cxx', line 26763

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

#StartDate(*args) ⇒ Object 



27379
27380
27381
27382
27383
27384
27385
27386
27387
27388
27389
27390
27391
27392
27393
27394
27395
27396
27397
27398
27399
27400
27401
27402
27403
27404
27405
27406
 
# File 'ext/ctp/ctp.cxx', line 27379

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

#StartDate=(*args) ⇒ Object 



27349
27350
27351
27352
27353
27354
27355
27356
27357
27358
27359
27360
27361
27362
27363
27364
27365
27366
27367
27368
27369
27370
27371
27372
27373
27374
27375
27376
 
# File 'ext/ctp/ctp.cxx', line 27349

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

#StartTime(*args) ⇒ Object 



27439
27440
27441
27442
27443
27444
27445
27446
27447
27448
27449
27450
27451
27452
27453
27454
27455
27456
27457
27458
27459
27460
27461
27462
27463
27464
27465
27466
 
# File 'ext/ctp/ctp.cxx', line 27439

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

#StartTime=(*args) ⇒ Object 



27409
27410
27411
27412
27413
27414
27415
27416
27417
27418
27419
27420
27421
27422
27423
27424
27425
27426
27427
27428
27429
27430
27431
27432
27433
27434
27435
27436
 
# File 'ext/ctp/ctp.cxx', line 27409

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

#TraderConnectStatus(*args) ⇒ Object 



26965
26966
26967
26968
26969
26970
26971
26972
26973
26974
26975
26976
26977
26978
26979
26980
26981
26982
26983
26984
26985
26986
 
# File 'ext/ctp/ctp.cxx', line 26965

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

#TraderConnectStatus=(*args) ⇒ Object 



26936
26937
26938
26939
26940
26941
26942
26943
26944
26945
26946
26947
26948
26949
26950
26951
26952
26953
26954
26955
26956
26957
26958
26959
26960
26961
26962
 
# File 'ext/ctp/ctp.cxx', line 26936

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

#TraderID(*args) ⇒ Object 



26673
26674
26675
26676
26677
26678
26679
26680
26681
26682
26683
26684
26685
26686
26687
26688
26689
26690
26691
26692
26693
26694
26695
26696
26697
26698
26699
26700
 
# File 'ext/ctp/ctp.cxx', line 26673

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

#TraderID=(*args) ⇒ Object 



26643
26644
26645
26646
26647
26648
26649
26650
26651
26652
26653
26654
26655
26656
26657
26658
26659
26660
26661
26662
26663
26664
26665
26666
26667
26668
26669
26670
 
# File 'ext/ctp/ctp.cxx', line 26643

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

#TradingDay(*args) ⇒ Object 



27499
27500
27501
27502
27503
27504
27505
27506
27507
27508
27509
27510
27511
27512
27513
27514
27515
27516
27517
27518
27519
27520
27521
27522
27523
27524
27525
27526
 
# File 'ext/ctp/ctp.cxx', line 27499

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



27469
27470
27471
27472
27473
27474
27475
27476
27477
27478
27479
27480
27481
27482
27483
27484
27485
27486
27487
27488
27489
27490
27491
27492
27493
27494
27495
27496
 
# File 'ext/ctp/ctp.cxx', line 27469

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