Class: Ctp::CThostFtdcMDTraderOfferField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



106717
106718
106719
106720
106721
106722
106723
106724
106725
106726
106727
106728
106729
106730
 
# File 'ext/ctp/ctp.cxx', line 106717

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

Instance Method Details

#BrokerID(*args) ⇒ Object 



106552
106553
106554
106555
106556
106557
106558
106559
106560
106561
106562
106563
106564
106565
106566
106567
106568
106569
106570
106571
106572
106573
106574
106575
106576
106577
106578
106579
 
# File 'ext/ctp/ctp.cxx', line 106552

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



106522
106523
106524
106525
106526
106527
106528
106529
106530
106531
106532
106533
106534
106535
106536
106537
106538
106539
106540
106541
106542
106543
106544
106545
106546
106547
106548
106549
 
# File 'ext/ctp/ctp.cxx', line 106522

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



106252
106253
106254
106255
106256
106257
106258
106259
106260
106261
106262
106263
106264
106265
106266
106267
106268
106269
106270
106271
106272
106273
106274
106275
106276
106277
106278
106279
 
# File 'ext/ctp/ctp.cxx', line 106252

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



106222
106223
106224
106225
106226
106227
106228
106229
106230
106231
106232
106233
106234
106235
106236
106237
106238
106239
106240
106241
106242
106243
106244
106245
106246
106247
106248
106249
 
# File 'ext/ctp/ctp.cxx', line 106222

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



106012
106013
106014
106015
106016
106017
106018
106019
106020
106021
106022
106023
106024
106025
106026
106027
106028
106029
106030
106031
106032
106033
106034
106035
106036
106037
106038
106039
 
# File 'ext/ctp/ctp.cxx', line 106012

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



105982
105983
105984
105985
105986
105987
105988
105989
105990
105991
105992
105993
105994
105995
105996
105997
105998
105999
106000
106001
106002
106003
106004
106005
106006
106007
106008
106009
 
# File 'ext/ctp/ctp.cxx', line 105982

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



106072
106073
106074
106075
106076
106077
106078
106079
106080
106081
106082
106083
106084
106085
106086
106087
106088
106089
106090
106091
106092
106093
106094
106095
106096
106097
106098
106099
 
# File 'ext/ctp/ctp.cxx', line 106072

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



106042
106043
106044
106045
106046
106047
106048
106049
106050
106051
106052
106053
106054
106055
106056
106057
106058
106059
106060
106061
106062
106063
106064
106065
106066
106067
106068
106069
 
# File 'ext/ctp/ctp.cxx', line 106042

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



106312
106313
106314
106315
106316
106317
106318
106319
106320
106321
106322
106323
106324
106325
106326
106327
106328
106329
106330
106331
106332
106333
106334
106335
106336
106337
106338
106339
 
# File 'ext/ctp/ctp.cxx', line 106312

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



106282
106283
106284
106285
106286
106287
106288
106289
106290
106291
106292
106293
106294
106295
106296
106297
106298
106299
106300
106301
106302
106303
106304
106305
106306
106307
106308
106309
 
# File 'ext/ctp/ctp.cxx', line 106282

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



105606
105607
105608
105609
105610
105611
105612
105613
105614
105615
105616
105617
105618
105619
105620
105621
105622
105623
105624
105625
105626
105627
105628
105629
105630
105631
105632
105633
 
# File 'ext/ctp/ctp.cxx', line 105606

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



105576
105577
105578
105579
105580
105581
105582
105583
105584
105585
105586
105587
105588
105589
105590
105591
105592
105593
105594
105595
105596
105597
105598
105599
105600
105601
105602
105603
 
# File 'ext/ctp/ctp.cxx', line 105576

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



105845
105846
105847
105848
105849
105850
105851
105852
105853
105854
105855
105856
105857
105858
105859
105860
105861
105862
105863
105864
105865
105866
 
# File 'ext/ctp/ctp.cxx', line 105845

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

#InstallID=(*args) ⇒ Object 



105816
105817
105818
105819
105820
105821
105822
105823
105824
105825
105826
105827
105828
105829
105830
105831
105832
105833
105834
105835
105836
105837
105838
105839
105840
105841
105842
 
# File 'ext/ctp/ctp.cxx', line 105816

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



106132
106133
106134
106135
106136
106137
106138
106139
106140
106141
106142
106143
106144
106145
106146
106147
106148
106149
106150
106151
106152
106153
106154
106155
106156
106157
106158
106159
 
# File 'ext/ctp/ctp.cxx', line 106132

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



106102
106103
106104
106105
106106
106107
106108
106109
106110
106111
106112
106113
106114
106115
106116
106117
106118
106119
106120
106121
106122
106123
106124
106125
106126
106127
106128
106129
 
# File 'ext/ctp/ctp.cxx', line 106102

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



106192
106193
106194
106195
106196
106197
106198
106199
106200
106201
106202
106203
106204
106205
106206
106207
106208
106209
106210
106211
106212
106213
106214
106215
106216
106217
106218
106219
 
# File 'ext/ctp/ctp.cxx', line 106192

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



106162
106163
106164
106165
106166
106167
106168
106169
106170
106171
106172
106173
106174
106175
106176
106177
106178
106179
106180
106181
106182
106183
106184
106185
106186
106187
106188
106189
 
# File 'ext/ctp/ctp.cxx', line 106162

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



106672
106673
106674
106675
106676
106677
106678
106679
106680
106681
106682
106683
106684
106685
106686
106687
106688
106689
106690
106691
106692
106693
106694
106695
106696
106697
106698
106699
 
# File 'ext/ctp/ctp.cxx', line 106672

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



106642
106643
106644
106645
106646
106647
106648
106649
106650
106651
106652
106653
106654
106655
106656
106657
106658
106659
106660
106661
106662
106663
106664
106665
106666
106667
106668
106669
 
# File 'ext/ctp/ctp.cxx', line 106642

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



106612
106613
106614
106615
106616
106617
106618
106619
106620
106621
106622
106623
106624
106625
106626
106627
106628
106629
106630
106631
106632
106633
106634
106635
106636
106637
106638
106639
 
# File 'ext/ctp/ctp.cxx', line 106612

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



106582
106583
106584
106585
106586
106587
106588
106589
106590
106591
106592
106593
106594
106595
106596
106597
106598
106599
106600
106601
106602
106603
106604
106605
106606
106607
106608
106609
 
# File 'ext/ctp/ctp.cxx', line 106582

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



105899
105900
105901
105902
105903
105904
105905
105906
105907
105908
105909
105910
105911
105912
105913
105914
105915
105916
105917
105918
105919
105920
105921
105922
105923
105924
105925
105926
 
# File 'ext/ctp/ctp.cxx', line 105899

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



105869
105870
105871
105872
105873
105874
105875
105876
105877
105878
105879
105880
105881
105882
105883
105884
105885
105886
105887
105888
105889
105890
105891
105892
105893
105894
105895
105896
 
# File 'ext/ctp/ctp.cxx', line 105869

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



105726
105727
105728
105729
105730
105731
105732
105733
105734
105735
105736
105737
105738
105739
105740
105741
105742
105743
105744
105745
105746
105747
105748
105749
105750
105751
105752
105753
 
# File 'ext/ctp/ctp.cxx', line 105726

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



105696
105697
105698
105699
105700
105701
105702
105703
105704
105705
105706
105707
105708
105709
105710
105711
105712
105713
105714
105715
105716
105717
105718
105719
105720
105721
105722
105723
 
# File 'ext/ctp/ctp.cxx', line 105696

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



105786
105787
105788
105789
105790
105791
105792
105793
105794
105795
105796
105797
105798
105799
105800
105801
105802
105803
105804
105805
105806
105807
105808
105809
105810
105811
105812
105813
 
# File 'ext/ctp/ctp.cxx', line 105786

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



105756
105757
105758
105759
105760
105761
105762
105763
105764
105765
105766
105767
105768
105769
105770
105771
105772
105773
105774
105775
105776
105777
105778
105779
105780
105781
105782
105783
 
# File 'ext/ctp/ctp.cxx', line 105756

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



106372
106373
106374
106375
106376
106377
106378
106379
106380
106381
106382
106383
106384
106385
106386
106387
106388
106389
106390
106391
106392
106393
106394
106395
106396
106397
106398
106399
 
# File 'ext/ctp/ctp.cxx', line 106372

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



106342
106343
106344
106345
106346
106347
106348
106349
106350
106351
106352
106353
106354
106355
106356
106357
106358
106359
106360
106361
106362
106363
106364
106365
106366
106367
106368
106369
 
# File 'ext/ctp/ctp.cxx', line 106342

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



106432
106433
106434
106435
106436
106437
106438
106439
106440
106441
106442
106443
106444
106445
106446
106447
106448
106449
106450
106451
106452
106453
106454
106455
106456
106457
106458
106459
 
# File 'ext/ctp/ctp.cxx', line 106432

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



106402
106403
106404
106405
106406
106407
106408
106409
106410
106411
106412
106413
106414
106415
106416
106417
106418
106419
106420
106421
106422
106423
106424
106425
106426
106427
106428
106429
 
# File 'ext/ctp/ctp.cxx', line 106402

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



105958
105959
105960
105961
105962
105963
105964
105965
105966
105967
105968
105969
105970
105971
105972
105973
105974
105975
105976
105977
105978
105979
 
# File 'ext/ctp/ctp.cxx', line 105958

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

#TraderConnectStatus=(*args) ⇒ Object 



105929
105930
105931
105932
105933
105934
105935
105936
105937
105938
105939
105940
105941
105942
105943
105944
105945
105946
105947
105948
105949
105950
105951
105952
105953
105954
105955
 
# File 'ext/ctp/ctp.cxx', line 105929

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



105666
105667
105668
105669
105670
105671
105672
105673
105674
105675
105676
105677
105678
105679
105680
105681
105682
105683
105684
105685
105686
105687
105688
105689
105690
105691
105692
105693
 
# File 'ext/ctp/ctp.cxx', line 105666

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



105636
105637
105638
105639
105640
105641
105642
105643
105644
105645
105646
105647
105648
105649
105650
105651
105652
105653
105654
105655
105656
105657
105658
105659
105660
105661
105662
105663
 
# File 'ext/ctp/ctp.cxx', line 105636

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



106492
106493
106494
106495
106496
106497
106498
106499
106500
106501
106502
106503
106504
106505
106506
106507
106508
106509
106510
106511
106512
106513
106514
106515
106516
106517
106518
106519
 
# File 'ext/ctp/ctp.cxx', line 106492

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



106462
106463
106464
106465
106466
106467
106468
106469
106470
106471
106472
106473
106474
106475
106476
106477
106478
106479
106480
106481
106482
106483
106484
106485
106486
106487
106488
106489
 
# File 'ext/ctp/ctp.cxx', line 106462

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