Class: Ctp::CThostFtdcInvestorPositionDetailField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



105273
105274
105275
105276
105277
105278
105279
105280
105281
105282
105283
105284
105285
105286
 
# File 'ext/ctp/ctp.cxx', line 105273

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

Instance Method Details

#BrokerID(*args) ⇒ Object 



103914
103915
103916
103917
103918
103919
103920
103921
103922
103923
103924
103925
103926
103927
103928
103929
103930
103931
103932
103933
103934
103935
103936
103937
103938
103939
103940
103941
 
# File 'ext/ctp/ctp.cxx', line 103914

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



103884
103885
103886
103887
103888
103889
103890
103891
103892
103893
103894
103895
103896
103897
103898
103899
103900
103901
103902
103903
103904
103905
103906
103907
103908
103909
103910
103911
 
# File 'ext/ctp/ctp.cxx', line 103884

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

#CloseAmount(*args) ⇒ Object 



105234
105235
105236
105237
105238
105239
105240
105241
105242
105243
105244
105245
105246
105247
105248
105249
105250
105251
105252
105253
105254
105255
 
# File 'ext/ctp/ctp.cxx', line 105234

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

#CloseAmount=(*args) ⇒ Object 



105205
105206
105207
105208
105209
105210
105211
105212
105213
105214
105215
105216
105217
105218
105219
105220
105221
105222
105223
105224
105225
105226
105227
105228
105229
105230
105231
 
# File 'ext/ctp/ctp.cxx', line 105205

SWIGINTERN VALUE
_wrap_CThostFtdcInvestorPositionDetailField_CloseAmount_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcInvestorPositionDetailField *arg1 = (CThostFtdcInvestorPositionDetailField *) 0 ;
  TThostFtdcMoneyType 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_CThostFtdcInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcInvestorPositionDetailField *","CloseAmount", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcInvestorPositionDetailField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcMoneyType","CloseAmount", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcMoneyType >(val2);
  if (arg1) (arg1)->CloseAmount = arg2;
  return Qnil;
fail:
  return Qnil;
}

#CloseProfitByDate(*args) ⇒ Object 



104651
104652
104653
104654
104655
104656
104657
104658
104659
104660
104661
104662
104663
104664
104665
104666
104667
104668
104669
104670
104671
104672
 
# File 'ext/ctp/ctp.cxx', line 104651

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

#CloseProfitByDate=(*args) ⇒ Object 



104622
104623
104624
104625
104626
104627
104628
104629
104630
104631
104632
104633
104634
104635
104636
104637
104638
104639
104640
104641
104642
104643
104644
104645
104646
104647
104648
 
# File 'ext/ctp/ctp.cxx', line 104622

SWIGINTERN VALUE
_wrap_CThostFtdcInvestorPositionDetailField_CloseProfitByDate_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcInvestorPositionDetailField *arg1 = (CThostFtdcInvestorPositionDetailField *) 0 ;
  TThostFtdcMoneyType 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_CThostFtdcInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcInvestorPositionDetailField *","CloseProfitByDate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcInvestorPositionDetailField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcMoneyType","CloseProfitByDate", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcMoneyType >(val2);
  if (arg1) (arg1)->CloseProfitByDate = arg2;
  return Qnil;
fail:
  return Qnil;
}

#CloseProfitByTrade(*args) ⇒ Object 



104704
104705
104706
104707
104708
104709
104710
104711
104712
104713
104714
104715
104716
104717
104718
104719
104720
104721
104722
104723
104724
104725
 
# File 'ext/ctp/ctp.cxx', line 104704

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

#CloseProfitByTrade=(*args) ⇒ Object 



104675
104676
104677
104678
104679
104680
104681
104682
104683
104684
104685
104686
104687
104688
104689
104690
104691
104692
104693
104694
104695
104696
104697
104698
104699
104700
104701
 
# File 'ext/ctp/ctp.cxx', line 104675

SWIGINTERN VALUE
_wrap_CThostFtdcInvestorPositionDetailField_CloseProfitByTrade_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcInvestorPositionDetailField *arg1 = (CThostFtdcInvestorPositionDetailField *) 0 ;
  TThostFtdcMoneyType 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_CThostFtdcInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcInvestorPositionDetailField *","CloseProfitByTrade", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcInvestorPositionDetailField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcMoneyType","CloseProfitByTrade", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcMoneyType >(val2);
  if (arg1) (arg1)->CloseProfitByTrade = arg2;
  return Qnil;
fail:
  return Qnil;
}

#CloseVolume(*args) ⇒ Object 



105181
105182
105183
105184
105185
105186
105187
105188
105189
105190
105191
105192
105193
105194
105195
105196
105197
105198
105199
105200
105201
105202
 
# File 'ext/ctp/ctp.cxx', line 105181

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

#CloseVolume=(*args) ⇒ Object 



105152
105153
105154
105155
105156
105157
105158
105159
105160
105161
105162
105163
105164
105165
105166
105167
105168
105169
105170
105171
105172
105173
105174
105175
105176
105177
105178
 
# File 'ext/ctp/ctp.cxx', line 105152

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

#CombInstrumentID(*args) ⇒ Object 



104532
104533
104534
104535
104536
104537
104538
104539
104540
104541
104542
104543
104544
104545
104546
104547
104548
104549
104550
104551
104552
104553
104554
104555
104556
104557
104558
104559
 
# File 'ext/ctp/ctp.cxx', line 104532

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

#CombInstrumentID=(*args) ⇒ Object 



104502
104503
104504
104505
104506
104507
104508
104509
104510
104511
104512
104513
104514
104515
104516
104517
104518
104519
104520
104521
104522
104523
104524
104525
104526
104527
104528
104529
 
# File 'ext/ctp/ctp.cxx', line 104502

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

#Direction(*args) ⇒ Object 



104086
104087
104088
104089
104090
104091
104092
104093
104094
104095
104096
104097
104098
104099
104100
104101
104102
104103
104104
104105
104106
104107
 
# File 'ext/ctp/ctp.cxx', line 104086

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

#Direction=(*args) ⇒ Object 



104057
104058
104059
104060
104061
104062
104063
104064
104065
104066
104067
104068
104069
104070
104071
104072
104073
104074
104075
104076
104077
104078
104079
104080
104081
104082
104083
 
# File 'ext/ctp/ctp.cxx', line 104057

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

#ExchangeID(*args) ⇒ Object 



104592
104593
104594
104595
104596
104597
104598
104599
104600
104601
104602
104603
104604
104605
104606
104607
104608
104609
104610
104611
104612
104613
104614
104615
104616
104617
104618
104619
 
# File 'ext/ctp/ctp.cxx', line 104592

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



104562
104563
104564
104565
104566
104567
104568
104569
104570
104571
104572
104573
104574
104575
104576
104577
104578
104579
104580
104581
104582
104583
104584
104585
104586
104587
104588
104589
 
# File 'ext/ctp/ctp.cxx', line 104562

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

#ExchMargin(*args) ⇒ Object 



104916
104917
104918
104919
104920
104921
104922
104923
104924
104925
104926
104927
104928
104929
104930
104931
104932
104933
104934
104935
104936
104937
 
# File 'ext/ctp/ctp.cxx', line 104916

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

#ExchMargin=(*args) ⇒ Object 



104887
104888
104889
104890
104891
104892
104893
104894
104895
104896
104897
104898
104899
104900
104901
104902
104903
104904
104905
104906
104907
104908
104909
104910
104911
104912
104913
 
# File 'ext/ctp/ctp.cxx', line 104887

SWIGINTERN VALUE
_wrap_CThostFtdcInvestorPositionDetailField_ExchMargin_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcInvestorPositionDetailField *arg1 = (CThostFtdcInvestorPositionDetailField *) 0 ;
  TThostFtdcMoneyType 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_CThostFtdcInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcInvestorPositionDetailField *","ExchMargin", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcInvestorPositionDetailField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcMoneyType","ExchMargin", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcMoneyType >(val2);
  if (arg1) (arg1)->ExchMargin = arg2;
  return Qnil;
fail:
  return Qnil;
}

#HedgeFlag(*args) ⇒ Object 



104033
104034
104035
104036
104037
104038
104039
104040
104041
104042
104043
104044
104045
104046
104047
104048
104049
104050
104051
104052
104053
104054
 
# File 'ext/ctp/ctp.cxx', line 104033

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

#HedgeFlag=(*args) ⇒ Object 



104004
104005
104006
104007
104008
104009
104010
104011
104012
104013
104014
104015
104016
104017
104018
104019
104020
104021
104022
104023
104024
104025
104026
104027
104028
104029
104030
 
# File 'ext/ctp/ctp.cxx', line 104004

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

#InstrumentID(*args) ⇒ Object 



103854
103855
103856
103857
103858
103859
103860
103861
103862
103863
103864
103865
103866
103867
103868
103869
103870
103871
103872
103873
103874
103875
103876
103877
103878
103879
103880
103881
 
# File 'ext/ctp/ctp.cxx', line 103854

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



103824
103825
103826
103827
103828
103829
103830
103831
103832
103833
103834
103835
103836
103837
103838
103839
103840
103841
103842
103843
103844
103845
103846
103847
103848
103849
103850
103851
 
# File 'ext/ctp/ctp.cxx', line 103824

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

#InvestorID(*args) ⇒ Object 



103974
103975
103976
103977
103978
103979
103980
103981
103982
103983
103984
103985
103986
103987
103988
103989
103990
103991
103992
103993
103994
103995
103996
103997
103998
103999
104000
104001
 
# File 'ext/ctp/ctp.cxx', line 103974

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

#InvestorID=(*args) ⇒ Object 



103944
103945
103946
103947
103948
103949
103950
103951
103952
103953
103954
103955
103956
103957
103958
103959
103960
103961
103962
103963
103964
103965
103966
103967
103968
103969
103970
103971
 
# File 'ext/ctp/ctp.cxx', line 103944

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

#LastSettlementPrice(*args) ⇒ Object 



105075
105076
105077
105078
105079
105080
105081
105082
105083
105084
105085
105086
105087
105088
105089
105090
105091
105092
105093
105094
105095
105096
 
# File 'ext/ctp/ctp.cxx', line 105075

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

#LastSettlementPrice=(*args) ⇒ Object 



105046
105047
105048
105049
105050
105051
105052
105053
105054
105055
105056
105057
105058
105059
105060
105061
105062
105063
105064
105065
105066
105067
105068
105069
105070
105071
105072
 
# File 'ext/ctp/ctp.cxx', line 105046

SWIGINTERN VALUE
_wrap_CThostFtdcInvestorPositionDetailField_LastSettlementPrice_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcInvestorPositionDetailField *arg1 = (CThostFtdcInvestorPositionDetailField *) 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_CThostFtdcInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcInvestorPositionDetailField *","LastSettlementPrice", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcInvestorPositionDetailField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcPriceType","LastSettlementPrice", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcPriceType >(val2);
  if (arg1) (arg1)->LastSettlementPrice = arg2;
  return Qnil;
fail:
  return Qnil;
}

#Margin(*args) ⇒ Object 



104863
104864
104865
104866
104867
104868
104869
104870
104871
104872
104873
104874
104875
104876
104877
104878
104879
104880
104881
104882
104883
104884
 
# File 'ext/ctp/ctp.cxx', line 104863

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

#Margin=(*args) ⇒ Object 



104834
104835
104836
104837
104838
104839
104840
104841
104842
104843
104844
104845
104846
104847
104848
104849
104850
104851
104852
104853
104854
104855
104856
104857
104858
104859
104860
 
# File 'ext/ctp/ctp.cxx', line 104834

SWIGINTERN VALUE
_wrap_CThostFtdcInvestorPositionDetailField_Margin_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcInvestorPositionDetailField *arg1 = (CThostFtdcInvestorPositionDetailField *) 0 ;
  TThostFtdcMoneyType 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_CThostFtdcInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcInvestorPositionDetailField *","Margin", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcInvestorPositionDetailField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcMoneyType","Margin", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcMoneyType >(val2);
  if (arg1) (arg1)->Margin = arg2;
  return Qnil;
fail:
  return Qnil;
}

#MarginRateByMoney(*args) ⇒ Object 



104969
104970
104971
104972
104973
104974
104975
104976
104977
104978
104979
104980
104981
104982
104983
104984
104985
104986
104987
104988
104989
104990
 
# File 'ext/ctp/ctp.cxx', line 104969

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

#MarginRateByMoney=(*args) ⇒ Object 



104940
104941
104942
104943
104944
104945
104946
104947
104948
104949
104950
104951
104952
104953
104954
104955
104956
104957
104958
104959
104960
104961
104962
104963
104964
104965
104966
 
# File 'ext/ctp/ctp.cxx', line 104940

SWIGINTERN VALUE
_wrap_CThostFtdcInvestorPositionDetailField_MarginRateByMoney_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcInvestorPositionDetailField *arg1 = (CThostFtdcInvestorPositionDetailField *) 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_CThostFtdcInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcInvestorPositionDetailField *","MarginRateByMoney", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcInvestorPositionDetailField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcRatioType","MarginRateByMoney", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcRatioType >(val2);
  if (arg1) (arg1)->MarginRateByMoney = arg2;
  return Qnil;
fail:
  return Qnil;
}

#MarginRateByVolume(*args) ⇒ Object 



105022
105023
105024
105025
105026
105027
105028
105029
105030
105031
105032
105033
105034
105035
105036
105037
105038
105039
105040
105041
105042
105043
 
# File 'ext/ctp/ctp.cxx', line 105022

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

#MarginRateByVolume=(*args) ⇒ Object 



104993
104994
104995
104996
104997
104998
104999
105000
105001
105002
105003
105004
105005
105006
105007
105008
105009
105010
105011
105012
105013
105014
105015
105016
105017
105018
105019
 
# File 'ext/ctp/ctp.cxx', line 104993

SWIGINTERN VALUE
_wrap_CThostFtdcInvestorPositionDetailField_MarginRateByVolume_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcInvestorPositionDetailField *arg1 = (CThostFtdcInvestorPositionDetailField *) 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_CThostFtdcInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcInvestorPositionDetailField *","MarginRateByVolume", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcInvestorPositionDetailField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcRatioType","MarginRateByVolume", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcRatioType >(val2);
  if (arg1) (arg1)->MarginRateByVolume = arg2;
  return Qnil;
fail:
  return Qnil;
}

#OpenDate(*args) ⇒ Object 



104140
104141
104142
104143
104144
104145
104146
104147
104148
104149
104150
104151
104152
104153
104154
104155
104156
104157
104158
104159
104160
104161
104162
104163
104164
104165
104166
104167
 
# File 'ext/ctp/ctp.cxx', line 104140

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



104110
104111
104112
104113
104114
104115
104116
104117
104118
104119
104120
104121
104122
104123
104124
104125
104126
104127
104128
104129
104130
104131
104132
104133
104134
104135
104136
104137
 
# File 'ext/ctp/ctp.cxx', line 104110

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

#OpenPrice(*args) ⇒ Object 



104312
104313
104314
104315
104316
104317
104318
104319
104320
104321
104322
104323
104324
104325
104326
104327
104328
104329
104330
104331
104332
104333
 
# File 'ext/ctp/ctp.cxx', line 104312

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

#OpenPrice=(*args) ⇒ Object 



104283
104284
104285
104286
104287
104288
104289
104290
104291
104292
104293
104294
104295
104296
104297
104298
104299
104300
104301
104302
104303
104304
104305
104306
104307
104308
104309
 
# File 'ext/ctp/ctp.cxx', line 104283

SWIGINTERN VALUE
_wrap_CThostFtdcInvestorPositionDetailField_OpenPrice_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcInvestorPositionDetailField *arg1 = (CThostFtdcInvestorPositionDetailField *) 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_CThostFtdcInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcInvestorPositionDetailField *","OpenPrice", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcInvestorPositionDetailField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcPriceType","OpenPrice", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcPriceType >(val2);
  if (arg1) (arg1)->OpenPrice = arg2;
  return Qnil;
fail:
  return Qnil;
}

#PositionProfitByDate(*args) ⇒ Object 



104757
104758
104759
104760
104761
104762
104763
104764
104765
104766
104767
104768
104769
104770
104771
104772
104773
104774
104775
104776
104777
104778
 
# File 'ext/ctp/ctp.cxx', line 104757

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

#PositionProfitByDate=(*args) ⇒ Object 



104728
104729
104730
104731
104732
104733
104734
104735
104736
104737
104738
104739
104740
104741
104742
104743
104744
104745
104746
104747
104748
104749
104750
104751
104752
104753
104754
 
# File 'ext/ctp/ctp.cxx', line 104728

SWIGINTERN VALUE
_wrap_CThostFtdcInvestorPositionDetailField_PositionProfitByDate_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcInvestorPositionDetailField *arg1 = (CThostFtdcInvestorPositionDetailField *) 0 ;
  TThostFtdcMoneyType 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_CThostFtdcInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcInvestorPositionDetailField *","PositionProfitByDate", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcInvestorPositionDetailField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcMoneyType","PositionProfitByDate", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcMoneyType >(val2);
  if (arg1) (arg1)->PositionProfitByDate = arg2;
  return Qnil;
fail:
  return Qnil;
}

#PositionProfitByTrade(*args) ⇒ Object 



104810
104811
104812
104813
104814
104815
104816
104817
104818
104819
104820
104821
104822
104823
104824
104825
104826
104827
104828
104829
104830
104831
 
# File 'ext/ctp/ctp.cxx', line 104810

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

#PositionProfitByTrade=(*args) ⇒ Object 



104781
104782
104783
104784
104785
104786
104787
104788
104789
104790
104791
104792
104793
104794
104795
104796
104797
104798
104799
104800
104801
104802
104803
104804
104805
104806
104807
 
# File 'ext/ctp/ctp.cxx', line 104781

SWIGINTERN VALUE
_wrap_CThostFtdcInvestorPositionDetailField_PositionProfitByTrade_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcInvestorPositionDetailField *arg1 = (CThostFtdcInvestorPositionDetailField *) 0 ;
  TThostFtdcMoneyType 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_CThostFtdcInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcInvestorPositionDetailField *","PositionProfitByTrade", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcInvestorPositionDetailField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcMoneyType","PositionProfitByTrade", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcMoneyType >(val2);
  if (arg1) (arg1)->PositionProfitByTrade = arg2;
  return Qnil;
fail:
  return Qnil;
}

#SettlementID(*args) ⇒ Object 



104425
104426
104427
104428
104429
104430
104431
104432
104433
104434
104435
104436
104437
104438
104439
104440
104441
104442
104443
104444
104445
104446
 
# File 'ext/ctp/ctp.cxx', line 104425

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

#SettlementID=(*args) ⇒ Object 



104396
104397
104398
104399
104400
104401
104402
104403
104404
104405
104406
104407
104408
104409
104410
104411
104412
104413
104414
104415
104416
104417
104418
104419
104420
104421
104422
 
# File 'ext/ctp/ctp.cxx', line 104396

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

#SettlementPrice(*args) ⇒ Object 



105128
105129
105130
105131
105132
105133
105134
105135
105136
105137
105138
105139
105140
105141
105142
105143
105144
105145
105146
105147
105148
105149
 
# File 'ext/ctp/ctp.cxx', line 105128

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

#SettlementPrice=(*args) ⇒ Object 



105099
105100
105101
105102
105103
105104
105105
105106
105107
105108
105109
105110
105111
105112
105113
105114
105115
105116
105117
105118
105119
105120
105121
105122
105123
105124
105125
 
# File 'ext/ctp/ctp.cxx', line 105099

SWIGINTERN VALUE
_wrap_CThostFtdcInvestorPositionDetailField_SettlementPrice_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcInvestorPositionDetailField *arg1 = (CThostFtdcInvestorPositionDetailField *) 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_CThostFtdcInvestorPositionDetailField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcInvestorPositionDetailField *","SettlementPrice", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcInvestorPositionDetailField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcPriceType","SettlementPrice", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcPriceType >(val2);
  if (arg1) (arg1)->SettlementPrice = arg2;
  return Qnil;
fail:
  return Qnil;
}

#TradeID(*args) ⇒ Object 



104200
104201
104202
104203
104204
104205
104206
104207
104208
104209
104210
104211
104212
104213
104214
104215
104216
104217
104218
104219
104220
104221
104222
104223
104224
104225
104226
104227
 
# File 'ext/ctp/ctp.cxx', line 104200

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

#TradeID=(*args) ⇒ Object 



104170
104171
104172
104173
104174
104175
104176
104177
104178
104179
104180
104181
104182
104183
104184
104185
104186
104187
104188
104189
104190
104191
104192
104193
104194
104195
104196
104197
 
# File 'ext/ctp/ctp.cxx', line 104170

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

#TradeType(*args) ⇒ Object 



104478
104479
104480
104481
104482
104483
104484
104485
104486
104487
104488
104489
104490
104491
104492
104493
104494
104495
104496
104497
104498
104499
 
# File 'ext/ctp/ctp.cxx', line 104478

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

#TradeType=(*args) ⇒ Object 



104449
104450
104451
104452
104453
104454
104455
104456
104457
104458
104459
104460
104461
104462
104463
104464
104465
104466
104467
104468
104469
104470
104471
104472
104473
104474
104475
 
# File 'ext/ctp/ctp.cxx', line 104449

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

#TradingDay(*args) ⇒ Object 



104366
104367
104368
104369
104370
104371
104372
104373
104374
104375
104376
104377
104378
104379
104380
104381
104382
104383
104384
104385
104386
104387
104388
104389
104390
104391
104392
104393
 
# File 'ext/ctp/ctp.cxx', line 104366

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



104336
104337
104338
104339
104340
104341
104342
104343
104344
104345
104346
104347
104348
104349
104350
104351
104352
104353
104354
104355
104356
104357
104358
104359
104360
104361
104362
104363
 
# File 'ext/ctp/ctp.cxx', line 104336

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

#Volume(*args) ⇒ Object 



104259
104260
104261
104262
104263
104264
104265
104266
104267
104268
104269
104270
104271
104272
104273
104274
104275
104276
104277
104278
104279
104280
 
# File 'ext/ctp/ctp.cxx', line 104259

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

#Volume=(*args) ⇒ Object 



104230
104231
104232
104233
104234
104235
104236
104237
104238
104239
104240
104241
104242
104243
104244
104245
104246
104247
104248
104249
104250
104251
104252
104253
104254
104255
104256
 
# File 'ext/ctp/ctp.cxx', line 104230

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