Class: Ctp::CThostFtdcInstrumentField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



14212
14213
14214
14215
14216
14217
14218
14219
14220
14221
14222
14223
14224
14225
 
# File 'ext/ctp/ctp.cxx', line 14212

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

Instance Method Details

#CombinationType(*args) ⇒ Object 



14173
14174
14175
14176
14177
14178
14179
14180
14181
14182
14183
14184
14185
14186
14187
14188
14189
14190
14191
14192
14193
14194
 
# File 'ext/ctp/ctp.cxx', line 14173

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

#CombinationType=(*args) ⇒ Object 



14144
14145
14146
14147
14148
14149
14150
14151
14152
14153
14154
14155
14156
14157
14158
14159
14160
14161
14162
14163
14164
14165
14166
14167
14168
14169
14170
 
# File 'ext/ctp/ctp.cxx', line 14144

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

#CreateDate(*args) ⇒ Object 



13284
13285
13286
13287
13288
13289
13290
13291
13292
13293
13294
13295
13296
13297
13298
13299
13300
13301
13302
13303
13304
13305
13306
13307
13308
13309
13310
13311
 
# File 'ext/ctp/ctp.cxx', line 13284

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

#CreateDate=(*args) ⇒ Object 



13254
13255
13256
13257
13258
13259
13260
13261
13262
13263
13264
13265
13266
13267
13268
13269
13270
13271
13272
13273
13274
13275
13276
13277
13278
13279
13280
13281
 
# File 'ext/ctp/ctp.cxx', line 13254

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

#DeliveryMonth(*args) ⇒ Object 



12912
12913
12914
12915
12916
12917
12918
12919
12920
12921
12922
12923
12924
12925
12926
12927
12928
12929
12930
12931
12932
12933
 
# File 'ext/ctp/ctp.cxx', line 12912

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

#DeliveryMonth=(*args) ⇒ Object 



12883
12884
12885
12886
12887
12888
12889
12890
12891
12892
12893
12894
12895
12896
12897
12898
12899
12900
12901
12902
12903
12904
12905
12906
12907
12908
12909
 
# File 'ext/ctp/ctp.cxx', line 12883

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

#DeliveryYear(*args) ⇒ Object 



12859
12860
12861
12862
12863
12864
12865
12866
12867
12868
12869
12870
12871
12872
12873
12874
12875
12876
12877
12878
12879
12880
 
# File 'ext/ctp/ctp.cxx', line 12859

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

#DeliveryYear=(*args) ⇒ Object 



12830
12831
12832
12833
12834
12835
12836
12837
12838
12839
12840
12841
12842
12843
12844
12845
12846
12847
12848
12849
12850
12851
12852
12853
12854
12855
12856
 
# File 'ext/ctp/ctp.cxx', line 12830

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

#EndDelivDate(*args) ⇒ Object 



13524
13525
13526
13527
13528
13529
13530
13531
13532
13533
13534
13535
13536
13537
13538
13539
13540
13541
13542
13543
13544
13545
13546
13547
13548
13549
13550
13551
 
# File 'ext/ctp/ctp.cxx', line 13524

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

#EndDelivDate=(*args) ⇒ Object 



13494
13495
13496
13497
13498
13499
13500
13501
13502
13503
13504
13505
13506
13507
13508
13509
13510
13511
13512
13513
13514
13515
13516
13517
13518
13519
13520
13521
 
# File 'ext/ctp/ctp.cxx', line 13494

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

#ExchangeID(*args) ⇒ Object 



12567
12568
12569
12570
12571
12572
12573
12574
12575
12576
12577
12578
12579
12580
12581
12582
12583
12584
12585
12586
12587
12588
12589
12590
12591
12592
12593
12594
 
# File 'ext/ctp/ctp.cxx', line 12567

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



12537
12538
12539
12540
12541
12542
12543
12544
12545
12546
12547
12548
12549
12550
12551
12552
12553
12554
12555
12556
12557
12558
12559
12560
12561
12562
12563
12564
 
# File 'ext/ctp/ctp.cxx', line 12537

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

#ExchangeInstID(*args) ⇒ Object 



12687
12688
12689
12690
12691
12692
12693
12694
12695
12696
12697
12698
12699
12700
12701
12702
12703
12704
12705
12706
12707
12708
12709
12710
12711
12712
12713
12714
 
# File 'ext/ctp/ctp.cxx', line 12687

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

#ExchangeInstID=(*args) ⇒ Object 



12657
12658
12659
12660
12661
12662
12663
12664
12665
12666
12667
12668
12669
12670
12671
12672
12673
12674
12675
12676
12677
12678
12679
12680
12681
12682
12683
12684
 
# File 'ext/ctp/ctp.cxx', line 12657

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

#ExpireDate(*args) ⇒ Object 



13404
13405
13406
13407
13408
13409
13410
13411
13412
13413
13414
13415
13416
13417
13418
13419
13420
13421
13422
13423
13424
13425
13426
13427
13428
13429
13430
13431
 
# File 'ext/ctp/ctp.cxx', line 13404

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

#ExpireDate=(*args) ⇒ Object 



13374
13375
13376
13377
13378
13379
13380
13381
13382
13383
13384
13385
13386
13387
13388
13389
13390
13391
13392
13393
13394
13395
13396
13397
13398
13399
13400
13401
 
# File 'ext/ctp/ctp.cxx', line 13374

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

#InstLifePhase(*args) ⇒ Object 



13583
13584
13585
13586
13587
13588
13589
13590
13591
13592
13593
13594
13595
13596
13597
13598
13599
13600
13601
13602
13603
13604
 
# File 'ext/ctp/ctp.cxx', line 13583

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

#InstLifePhase=(*args) ⇒ Object 



13554
13555
13556
13557
13558
13559
13560
13561
13562
13563
13564
13565
13566
13567
13568
13569
13570
13571
13572
13573
13574
13575
13576
13577
13578
13579
13580
 
# File 'ext/ctp/ctp.cxx', line 13554

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

#InstrumentID(*args) ⇒ Object 



12507
12508
12509
12510
12511
12512
12513
12514
12515
12516
12517
12518
12519
12520
12521
12522
12523
12524
12525
12526
12527
12528
12529
12530
12531
12532
12533
12534
 
# File 'ext/ctp/ctp.cxx', line 12507

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

#InstrumentID=(*args) ⇒ Object 



12477
12478
12479
12480
12481
12482
12483
12484
12485
12486
12487
12488
12489
12490
12491
12492
12493
12494
12495
12496
12497
12498
12499
12500
12501
12502
12503
12504
 
# File 'ext/ctp/ctp.cxx', line 12477

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

#InstrumentName(*args) ⇒ Object 



12627
12628
12629
12630
12631
12632
12633
12634
12635
12636
12637
12638
12639
12640
12641
12642
12643
12644
12645
12646
12647
12648
12649
12650
12651
12652
12653
12654
 
# File 'ext/ctp/ctp.cxx', line 12627

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

#InstrumentName=(*args) ⇒ Object 



12597
12598
12599
12600
12601
12602
12603
12604
12605
12606
12607
12608
12609
12610
12611
12612
12613
12614
12615
12616
12617
12618
12619
12620
12621
12622
12623
12624
 
# File 'ext/ctp/ctp.cxx', line 12597

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

#IsTrading(*args) ⇒ Object 



13636
13637
13638
13639
13640
13641
13642
13643
13644
13645
13646
13647
13648
13649
13650
13651
13652
13653
13654
13655
13656
13657
 
# File 'ext/ctp/ctp.cxx', line 13636

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

#IsTrading=(*args) ⇒ Object 



13607
13608
13609
13610
13611
13612
13613
13614
13615
13616
13617
13618
13619
13620
13621
13622
13623
13624
13625
13626
13627
13628
13629
13630
13631
13632
13633
 
# File 'ext/ctp/ctp.cxx', line 13607

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

#LongMarginRatio(*args) ⇒ Object 



13795
13796
13797
13798
13799
13800
13801
13802
13803
13804
13805
13806
13807
13808
13809
13810
13811
13812
13813
13814
13815
13816
 
# File 'ext/ctp/ctp.cxx', line 13795

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

#LongMarginRatio=(*args) ⇒ Object 



13766
13767
13768
13769
13770
13771
13772
13773
13774
13775
13776
13777
13778
13779
13780
13781
13782
13783
13784
13785
13786
13787
13788
13789
13790
13791
13792
 
# File 'ext/ctp/ctp.cxx', line 13766

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

#MaxLimitOrderVolume(*args) ⇒ Object 



13071
13072
13073
13074
13075
13076
13077
13078
13079
13080
13081
13082
13083
13084
13085
13086
13087
13088
13089
13090
13091
13092
 
# File 'ext/ctp/ctp.cxx', line 13071

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

#MaxLimitOrderVolume=(*args) ⇒ Object 



13042
13043
13044
13045
13046
13047
13048
13049
13050
13051
13052
13053
13054
13055
13056
13057
13058
13059
13060
13061
13062
13063
13064
13065
13066
13067
13068
 
# File 'ext/ctp/ctp.cxx', line 13042

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

#MaxMarginSideAlgorithm(*args) ⇒ Object 



13901
13902
13903
13904
13905
13906
13907
13908
13909
13910
13911
13912
13913
13914
13915
13916
13917
13918
13919
13920
13921
13922
 
# File 'ext/ctp/ctp.cxx', line 13901

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

#MaxMarginSideAlgorithm=(*args) ⇒ Object 



13872
13873
13874
13875
13876
13877
13878
13879
13880
13881
13882
13883
13884
13885
13886
13887
13888
13889
13890
13891
13892
13893
13894
13895
13896
13897
13898
 
# File 'ext/ctp/ctp.cxx', line 13872

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

#MaxMarketOrderVolume(*args) ⇒ Object 



12965
12966
12967
12968
12969
12970
12971
12972
12973
12974
12975
12976
12977
12978
12979
12980
12981
12982
12983
12984
12985
12986
 
# File 'ext/ctp/ctp.cxx', line 12965

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

#MaxMarketOrderVolume=(*args) ⇒ Object 



12936
12937
12938
12939
12940
12941
12942
12943
12944
12945
12946
12947
12948
12949
12950
12951
12952
12953
12954
12955
12956
12957
12958
12959
12960
12961
12962
 
# File 'ext/ctp/ctp.cxx', line 12936

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

#MinLimitOrderVolume(*args) ⇒ Object 



13124
13125
13126
13127
13128
13129
13130
13131
13132
13133
13134
13135
13136
13137
13138
13139
13140
13141
13142
13143
13144
13145
 
# File 'ext/ctp/ctp.cxx', line 13124

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

#MinLimitOrderVolume=(*args) ⇒ Object 



13095
13096
13097
13098
13099
13100
13101
13102
13103
13104
13105
13106
13107
13108
13109
13110
13111
13112
13113
13114
13115
13116
13117
13118
13119
13120
13121
 
# File 'ext/ctp/ctp.cxx', line 13095

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

#MinMarketOrderVolume(*args) ⇒ Object 



13018
13019
13020
13021
13022
13023
13024
13025
13026
13027
13028
13029
13030
13031
13032
13033
13034
13035
13036
13037
13038
13039
 
# File 'ext/ctp/ctp.cxx', line 13018

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

#MinMarketOrderVolume=(*args) ⇒ Object 



12989
12990
12991
12992
12993
12994
12995
12996
12997
12998
12999
13000
13001
13002
13003
13004
13005
13006
13007
13008
13009
13010
13011
13012
13013
13014
13015
 
# File 'ext/ctp/ctp.cxx', line 12989

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

#OpenDate(*args) ⇒ Object 



13344
13345
13346
13347
13348
13349
13350
13351
13352
13353
13354
13355
13356
13357
13358
13359
13360
13361
13362
13363
13364
13365
13366
13367
13368
13369
13370
13371
 
# File 'ext/ctp/ctp.cxx', line 13344

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

#OpenDate=(*args) ⇒ Object 



13314
13315
13316
13317
13318
13319
13320
13321
13322
13323
13324
13325
13326
13327
13328
13329
13330
13331
13332
13333
13334
13335
13336
13337
13338
13339
13340
13341
 
# File 'ext/ctp/ctp.cxx', line 13314

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

#OptionsType(*args) ⇒ Object 



14067
14068
14069
14070
14071
14072
14073
14074
14075
14076
14077
14078
14079
14080
14081
14082
14083
14084
14085
14086
14087
14088
 
# File 'ext/ctp/ctp.cxx', line 14067

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

#OptionsType=(*args) ⇒ Object 



14038
14039
14040
14041
14042
14043
14044
14045
14046
14047
14048
14049
14050
14051
14052
14053
14054
14055
14056
14057
14058
14059
14060
14061
14062
14063
14064
 
# File 'ext/ctp/ctp.cxx', line 14038

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

#PositionDateType(*args) ⇒ Object 



13742
13743
13744
13745
13746
13747
13748
13749
13750
13751
13752
13753
13754
13755
13756
13757
13758
13759
13760
13761
13762
13763
 
# File 'ext/ctp/ctp.cxx', line 13742

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

#PositionDateType=(*args) ⇒ Object 



13713
13714
13715
13716
13717
13718
13719
13720
13721
13722
13723
13724
13725
13726
13727
13728
13729
13730
13731
13732
13733
13734
13735
13736
13737
13738
13739
 
# File 'ext/ctp/ctp.cxx', line 13713

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

#PositionType(*args) ⇒ Object 



13689
13690
13691
13692
13693
13694
13695
13696
13697
13698
13699
13700
13701
13702
13703
13704
13705
13706
13707
13708
13709
13710
 
# File 'ext/ctp/ctp.cxx', line 13689

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

#PositionType=(*args) ⇒ Object 



13660
13661
13662
13663
13664
13665
13666
13667
13668
13669
13670
13671
13672
13673
13674
13675
13676
13677
13678
13679
13680
13681
13682
13683
13684
13685
13686
 
# File 'ext/ctp/ctp.cxx', line 13660

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

#PriceTick(*args) ⇒ Object 



13230
13231
13232
13233
13234
13235
13236
13237
13238
13239
13240
13241
13242
13243
13244
13245
13246
13247
13248
13249
13250
13251
 
# File 'ext/ctp/ctp.cxx', line 13230

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

#PriceTick=(*args) ⇒ Object 



13201
13202
13203
13204
13205
13206
13207
13208
13209
13210
13211
13212
13213
13214
13215
13216
13217
13218
13219
13220
13221
13222
13223
13224
13225
13226
13227
 
# File 'ext/ctp/ctp.cxx', line 13201

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

#ProductClass(*args) ⇒ Object 



12806
12807
12808
12809
12810
12811
12812
12813
12814
12815
12816
12817
12818
12819
12820
12821
12822
12823
12824
12825
12826
12827
 
# File 'ext/ctp/ctp.cxx', line 12806

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

#ProductClass=(*args) ⇒ Object 



12777
12778
12779
12780
12781
12782
12783
12784
12785
12786
12787
12788
12789
12790
12791
12792
12793
12794
12795
12796
12797
12798
12799
12800
12801
12802
12803
 
# File 'ext/ctp/ctp.cxx', line 12777

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

#ProductID(*args) ⇒ Object 



12747
12748
12749
12750
12751
12752
12753
12754
12755
12756
12757
12758
12759
12760
12761
12762
12763
12764
12765
12766
12767
12768
12769
12770
12771
12772
12773
12774
 
# File 'ext/ctp/ctp.cxx', line 12747

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

#ProductID=(*args) ⇒ Object 



12717
12718
12719
12720
12721
12722
12723
12724
12725
12726
12727
12728
12729
12730
12731
12732
12733
12734
12735
12736
12737
12738
12739
12740
12741
12742
12743
12744
 
# File 'ext/ctp/ctp.cxx', line 12717

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

#ShortMarginRatio(*args) ⇒ Object 



13848
13849
13850
13851
13852
13853
13854
13855
13856
13857
13858
13859
13860
13861
13862
13863
13864
13865
13866
13867
13868
13869
 
# File 'ext/ctp/ctp.cxx', line 13848

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

#ShortMarginRatio=(*args) ⇒ Object 



13819
13820
13821
13822
13823
13824
13825
13826
13827
13828
13829
13830
13831
13832
13833
13834
13835
13836
13837
13838
13839
13840
13841
13842
13843
13844
13845
 
# File 'ext/ctp/ctp.cxx', line 13819

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

#StartDelivDate(*args) ⇒ Object 



13464
13465
13466
13467
13468
13469
13470
13471
13472
13473
13474
13475
13476
13477
13478
13479
13480
13481
13482
13483
13484
13485
13486
13487
13488
13489
13490
13491
 
# File 'ext/ctp/ctp.cxx', line 13464

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

#StartDelivDate=(*args) ⇒ Object 



13434
13435
13436
13437
13438
13439
13440
13441
13442
13443
13444
13445
13446
13447
13448
13449
13450
13451
13452
13453
13454
13455
13456
13457
13458
13459
13460
13461
 
# File 'ext/ctp/ctp.cxx', line 13434

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

#StrikePrice(*args) ⇒ Object 



14014
14015
14016
14017
14018
14019
14020
14021
14022
14023
14024
14025
14026
14027
14028
14029
14030
14031
14032
14033
14034
14035
 
# File 'ext/ctp/ctp.cxx', line 14014

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

#StrikePrice=(*args) ⇒ Object 



13985
13986
13987
13988
13989
13990
13991
13992
13993
13994
13995
13996
13997
13998
13999
14000
14001
14002
14003
14004
14005
14006
14007
14008
14009
14010
14011
 
# File 'ext/ctp/ctp.cxx', line 13985

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

#UnderlyingInstrID(*args) ⇒ Object 



13955
13956
13957
13958
13959
13960
13961
13962
13963
13964
13965
13966
13967
13968
13969
13970
13971
13972
13973
13974
13975
13976
13977
13978
13979
13980
13981
13982
 
# File 'ext/ctp/ctp.cxx', line 13955

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

#UnderlyingInstrID=(*args) ⇒ Object 



13925
13926
13927
13928
13929
13930
13931
13932
13933
13934
13935
13936
13937
13938
13939
13940
13941
13942
13943
13944
13945
13946
13947
13948
13949
13950
13951
13952
 
# File 'ext/ctp/ctp.cxx', line 13925

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

#UnderlyingMultiple(*args) ⇒ Object 



14120
14121
14122
14123
14124
14125
14126
14127
14128
14129
14130
14131
14132
14133
14134
14135
14136
14137
14138
14139
14140
14141
 
# File 'ext/ctp/ctp.cxx', line 14120

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

#UnderlyingMultiple=(*args) ⇒ Object 



14091
14092
14093
14094
14095
14096
14097
14098
14099
14100
14101
14102
14103
14104
14105
14106
14107
14108
14109
14110
14111
14112
14113
14114
14115
14116
14117
 
# File 'ext/ctp/ctp.cxx', line 14091

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

#VolumeMultiple(*args) ⇒ Object 



13177
13178
13179
13180
13181
13182
13183
13184
13185
13186
13187
13188
13189
13190
13191
13192
13193
13194
13195
13196
13197
13198
 
# File 'ext/ctp/ctp.cxx', line 13177

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

#VolumeMultiple=(*args) ⇒ Object 



13148
13149
13150
13151
13152
13153
13154
13155
13156
13157
13158
13159
13160
13161
13162
13163
13164
13165
13166
13167
13168
13169
13170
13171
13172
13173
13174
 
# File 'ext/ctp/ctp.cxx', line 13148

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