Class: Ctp::CThostFtdcTradingAccountField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



19486
19487
19488
19489
19490
19491
19492
19493
19494
19495
19496
19497
19498
19499
 
# File 'ext/ctp/ctp.cxx', line 19486

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

Instance Method Details

#AccountID(*args) ⇒ Object 



17095
17096
17097
17098
17099
17100
17101
17102
17103
17104
17105
17106
17107
17108
17109
17110
17111
17112
17113
17114
17115
17116
17117
17118
17119
17120
17121
17122
 
# File 'ext/ctp/ctp.cxx', line 17095

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

#AccountID=(*args) ⇒ Object 



17065
17066
17067
17068
17069
17070
17071
17072
17073
17074
17075
17076
17077
17078
17079
17080
17081
17082
17083
17084
17085
17086
17087
17088
17089
17090
17091
17092
 
# File 'ext/ctp/ctp.cxx', line 17065

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

#Available(*args) ⇒ Object 



18108
18109
18110
18111
18112
18113
18114
18115
18116
18117
18118
18119
18120
18121
18122
18123
18124
18125
18126
18127
18128
18129
 
# File 'ext/ctp/ctp.cxx', line 18108

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

#Available=(*args) ⇒ Object 



18079
18080
18081
18082
18083
18084
18085
18086
18087
18088
18089
18090
18091
18092
18093
18094
18095
18096
18097
18098
18099
18100
18101
18102
18103
18104
18105
 
# File 'ext/ctp/ctp.cxx', line 18079

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

#Balance(*args) ⇒ Object 



18055
18056
18057
18058
18059
18060
18061
18062
18063
18064
18065
18066
18067
18068
18069
18070
18071
18072
18073
18074
18075
18076
 
# File 'ext/ctp/ctp.cxx', line 18055

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

#Balance=(*args) ⇒ Object 



18026
18027
18028
18029
18030
18031
18032
18033
18034
18035
18036
18037
18038
18039
18040
18041
18042
18043
18044
18045
18046
18047
18048
18049
18050
18051
18052
 
# File 'ext/ctp/ctp.cxx', line 18026

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

#BrokerID(*args) ⇒ Object 



17035
17036
17037
17038
17039
17040
17041
17042
17043
17044
17045
17046
17047
17048
17049
17050
17051
17052
17053
17054
17055
17056
17057
17058
17059
17060
17061
17062
 
# File 'ext/ctp/ctp.cxx', line 17035

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



17005
17006
17007
17008
17009
17010
17011
17012
17013
17014
17015
17016
17017
17018
17019
17020
17021
17022
17023
17024
17025
17026
17027
17028
17029
17030
17031
17032
 
# File 'ext/ctp/ctp.cxx', line 17005

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

#CashIn(*args) ⇒ Object 



17843
17844
17845
17846
17847
17848
17849
17850
17851
17852
17853
17854
17855
17856
17857
17858
17859
17860
17861
17862
17863
17864
 
# File 'ext/ctp/ctp.cxx', line 17843

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

#CashIn=(*args) ⇒ Object 



17814
17815
17816
17817
17818
17819
17820
17821
17822
17823
17824
17825
17826
17827
17828
17829
17830
17831
17832
17833
17834
17835
17836
17837
17838
17839
17840
 
# File 'ext/ctp/ctp.cxx', line 17814

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

#CloseProfit(*args) ⇒ Object 



17949
17950
17951
17952
17953
17954
17955
17956
17957
17958
17959
17960
17961
17962
17963
17964
17965
17966
17967
17968
17969
17970
 
# File 'ext/ctp/ctp.cxx', line 17949

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

#CloseProfit=(*args) ⇒ Object 



17920
17921
17922
17923
17924
17925
17926
17927
17928
17929
17930
17931
17932
17933
17934
17935
17936
17937
17938
17939
17940
17941
17942
17943
17944
17945
17946
 
# File 'ext/ctp/ctp.cxx', line 17920

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

#Commission(*args) ⇒ Object 



17896
17897
17898
17899
17900
17901
17902
17903
17904
17905
17906
17907
17908
17909
17910
17911
17912
17913
17914
17915
17916
17917
 
# File 'ext/ctp/ctp.cxx', line 17896

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

#Commission=(*args) ⇒ Object 



17867
17868
17869
17870
17871
17872
17873
17874
17875
17876
17877
17878
17879
17880
17881
17882
17883
17884
17885
17886
17887
17888
17889
17890
17891
17892
17893
 
# File 'ext/ctp/ctp.cxx', line 17867

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

#Credit(*args) ⇒ Object 



18380
18381
18382
18383
18384
18385
18386
18387
18388
18389
18390
18391
18392
18393
18394
18395
18396
18397
18398
18399
18400
18401
 
# File 'ext/ctp/ctp.cxx', line 18380

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

#Credit=(*args) ⇒ Object 



18351
18352
18353
18354
18355
18356
18357
18358
18359
18360
18361
18362
18363
18364
18365
18366
18367
18368
18369
18370
18371
18372
18373
18374
18375
18376
18377
 
# File 'ext/ctp/ctp.cxx', line 18351

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

#CurrencyID(*args) ⇒ Object 



18699
18700
18701
18702
18703
18704
18705
18706
18707
18708
18709
18710
18711
18712
18713
18714
18715
18716
18717
18718
18719
18720
18721
18722
18723
18724
18725
18726
 
# File 'ext/ctp/ctp.cxx', line 18699

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

#CurrencyID=(*args) ⇒ Object 



18669
18670
18671
18672
18673
18674
18675
18676
18677
18678
18679
18680
18681
18682
18683
18684
18685
18686
18687
18688
18689
18690
18691
18692
18693
18694
18695
18696
 
# File 'ext/ctp/ctp.cxx', line 18669

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

#CurrMargin(*args) ⇒ Object 



17790
17791
17792
17793
17794
17795
17796
17797
17798
17799
17800
17801
17802
17803
17804
17805
17806
17807
17808
17809
17810
17811
 
# File 'ext/ctp/ctp.cxx', line 17790

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

#CurrMargin=(*args) ⇒ Object 



17761
17762
17763
17764
17765
17766
17767
17768
17769
17770
17771
17772
17773
17774
17775
17776
17777
17778
17779
17780
17781
17782
17783
17784
17785
17786
17787
 
# File 'ext/ctp/ctp.cxx', line 17761

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

#DeliveryMargin(*args) ⇒ Object 



18539
18540
18541
18542
18543
18544
18545
18546
18547
18548
18549
18550
18551
18552
18553
18554
18555
18556
18557
18558
18559
18560
 
# File 'ext/ctp/ctp.cxx', line 18539

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

#DeliveryMargin=(*args) ⇒ Object 



18510
18511
18512
18513
18514
18515
18516
18517
18518
18519
18520
18521
18522
18523
18524
18525
18526
18527
18528
18529
18530
18531
18532
18533
18534
18535
18536
 
# File 'ext/ctp/ctp.cxx', line 18510

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

#Deposit(*args) ⇒ Object 



17525
17526
17527
17528
17529
17530
17531
17532
17533
17534
17535
17536
17537
17538
17539
17540
17541
17542
17543
17544
17545
17546
 
# File 'ext/ctp/ctp.cxx', line 17525

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

#Deposit=(*args) ⇒ Object 



17496
17497
17498
17499
17500
17501
17502
17503
17504
17505
17506
17507
17508
17509
17510
17511
17512
17513
17514
17515
17516
17517
17518
17519
17520
17521
17522
 
# File 'ext/ctp/ctp.cxx', line 17496

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

#ExchangeDeliveryMargin(*args) ⇒ Object 



18592
18593
18594
18595
18596
18597
18598
18599
18600
18601
18602
18603
18604
18605
18606
18607
18608
18609
18610
18611
18612
18613
 
# File 'ext/ctp/ctp.cxx', line 18592

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

#ExchangeDeliveryMargin=(*args) ⇒ Object 



18563
18564
18565
18566
18567
18568
18569
18570
18571
18572
18573
18574
18575
18576
18577
18578
18579
18580
18581
18582
18583
18584
18585
18586
18587
18588
18589
 
# File 'ext/ctp/ctp.cxx', line 18563

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

#ExchangeMargin(*args) ⇒ Object 



18486
18487
18488
18489
18490
18491
18492
18493
18494
18495
18496
18497
18498
18499
18500
18501
18502
18503
18504
18505
18506
18507
 
# File 'ext/ctp/ctp.cxx', line 18486

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

#ExchangeMargin=(*args) ⇒ Object 



18457
18458
18459
18460
18461
18462
18463
18464
18465
18466
18467
18468
18469
18470
18471
18472
18473
18474
18475
18476
18477
18478
18479
18480
18481
18482
18483
 
# File 'ext/ctp/ctp.cxx', line 18457

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

#FrozenCash(*args) ⇒ Object 



17684
17685
17686
17687
17688
17689
17690
17691
17692
17693
17694
17695
17696
17697
17698
17699
17700
17701
17702
17703
17704
17705
 
# File 'ext/ctp/ctp.cxx', line 17684

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

#FrozenCash=(*args) ⇒ Object 



17655
17656
17657
17658
17659
17660
17661
17662
17663
17664
17665
17666
17667
17668
17669
17670
17671
17672
17673
17674
17675
17676
17677
17678
17679
17680
17681
 
# File 'ext/ctp/ctp.cxx', line 17655

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

#FrozenCommission(*args) ⇒ Object 



17737
17738
17739
17740
17741
17742
17743
17744
17745
17746
17747
17748
17749
17750
17751
17752
17753
17754
17755
17756
17757
17758
 
# File 'ext/ctp/ctp.cxx', line 17737

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

#FrozenCommission=(*args) ⇒ Object 



17708
17709
17710
17711
17712
17713
17714
17715
17716
17717
17718
17719
17720
17721
17722
17723
17724
17725
17726
17727
17728
17729
17730
17731
17732
17733
17734
 
# File 'ext/ctp/ctp.cxx', line 17708

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

#FrozenMargin(*args) ⇒ Object 



17631
17632
17633
17634
17635
17636
17637
17638
17639
17640
17641
17642
17643
17644
17645
17646
17647
17648
17649
17650
17651
17652
 
# File 'ext/ctp/ctp.cxx', line 17631

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

#FrozenMargin=(*args) ⇒ Object 



17602
17603
17604
17605
17606
17607
17608
17609
17610
17611
17612
17613
17614
17615
17616
17617
17618
17619
17620
17621
17622
17623
17624
17625
17626
17627
17628
 
# File 'ext/ctp/ctp.cxx', line 17602

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

#FundMortgageAvailable(*args) ⇒ Object 



18970
18971
18972
18973
18974
18975
18976
18977
18978
18979
18980
18981
18982
18983
18984
18985
18986
18987
18988
18989
18990
18991
 
# File 'ext/ctp/ctp.cxx', line 18970

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

#FundMortgageAvailable=(*args) ⇒ Object 



18941
18942
18943
18944
18945
18946
18947
18948
18949
18950
18951
18952
18953
18954
18955
18956
18957
18958
18959
18960
18961
18962
18963
18964
18965
18966
18967
 
# File 'ext/ctp/ctp.cxx', line 18941

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

#FundMortgageIn(*args) ⇒ Object 



18864
18865
18866
18867
18868
18869
18870
18871
18872
18873
18874
18875
18876
18877
18878
18879
18880
18881
18882
18883
18884
18885
 
# File 'ext/ctp/ctp.cxx', line 18864

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

#FundMortgageIn=(*args) ⇒ Object 



18835
18836
18837
18838
18839
18840
18841
18842
18843
18844
18845
18846
18847
18848
18849
18850
18851
18852
18853
18854
18855
18856
18857
18858
18859
18860
18861
 
# File 'ext/ctp/ctp.cxx', line 18835

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

#FundMortgageOut(*args) ⇒ Object 



18917
18918
18919
18920
18921
18922
18923
18924
18925
18926
18927
18928
18929
18930
18931
18932
18933
18934
18935
18936
18937
18938
 
# File 'ext/ctp/ctp.cxx', line 18917

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

#FundMortgageOut=(*args) ⇒ Object 



18888
18889
18890
18891
18892
18893
18894
18895
18896
18897
18898
18899
18900
18901
18902
18903
18904
18905
18906
18907
18908
18909
18910
18911
18912
18913
18914
 
# File 'ext/ctp/ctp.cxx', line 18888

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

#Interest(*args) ⇒ Object 



17472
17473
17474
17475
17476
17477
17478
17479
17480
17481
17482
17483
17484
17485
17486
17487
17488
17489
17490
17491
17492
17493
 
# File 'ext/ctp/ctp.cxx', line 17472

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

#Interest=(*args) ⇒ Object 



17443
17444
17445
17446
17447
17448
17449
17450
17451
17452
17453
17454
17455
17456
17457
17458
17459
17460
17461
17462
17463
17464
17465
17466
17467
17468
17469
 
# File 'ext/ctp/ctp.cxx', line 17443

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

#InterestBase(*args) ⇒ Object 



17419
17420
17421
17422
17423
17424
17425
17426
17427
17428
17429
17430
17431
17432
17433
17434
17435
17436
17437
17438
17439
17440
 
# File 'ext/ctp/ctp.cxx', line 17419

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

#InterestBase=(*args) ⇒ Object 



17390
17391
17392
17393
17394
17395
17396
17397
17398
17399
17400
17401
17402
17403
17404
17405
17406
17407
17408
17409
17410
17411
17412
17413
17414
17415
17416
 
# File 'ext/ctp/ctp.cxx', line 17390

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

#Mortgage(*args) ⇒ Object 



18433
18434
18435
18436
18437
18438
18439
18440
18441
18442
18443
18444
18445
18446
18447
18448
18449
18450
18451
18452
18453
18454
 
# File 'ext/ctp/ctp.cxx', line 18433

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

#Mortgage=(*args) ⇒ Object 



18404
18405
18406
18407
18408
18409
18410
18411
18412
18413
18414
18415
18416
18417
18418
18419
18420
18421
18422
18423
18424
18425
18426
18427
18428
18429
18430
 
# File 'ext/ctp/ctp.cxx', line 18404

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

#MortgageableFund(*args) ⇒ Object 



19023
19024
19025
19026
19027
19028
19029
19030
19031
19032
19033
19034
19035
19036
19037
19038
19039
19040
19041
19042
19043
19044
 
# File 'ext/ctp/ctp.cxx', line 19023

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

#MortgageableFund=(*args) ⇒ Object 



18994
18995
18996
18997
18998
18999
19000
19001
19002
19003
19004
19005
19006
19007
19008
19009
19010
19011
19012
19013
19014
19015
19016
19017
19018
19019
19020
 
# File 'ext/ctp/ctp.cxx', line 18994

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

#PositionProfit(*args) ⇒ Object 



18002
18003
18004
18005
18006
18007
18008
18009
18010
18011
18012
18013
18014
18015
18016
18017
18018
18019
18020
18021
18022
18023
 
# File 'ext/ctp/ctp.cxx', line 18002

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

#PositionProfit=(*args) ⇒ Object 



17973
17974
17975
17976
17977
17978
17979
17980
17981
17982
17983
17984
17985
17986
17987
17988
17989
17990
17991
17992
17993
17994
17995
17996
17997
17998
17999
 
# File 'ext/ctp/ctp.cxx', line 17973

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

#PreBalance(*args) ⇒ Object 



17313
17314
17315
17316
17317
17318
17319
17320
17321
17322
17323
17324
17325
17326
17327
17328
17329
17330
17331
17332
17333
17334
 
# File 'ext/ctp/ctp.cxx', line 17313

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

#PreBalance=(*args) ⇒ Object 



17284
17285
17286
17287
17288
17289
17290
17291
17292
17293
17294
17295
17296
17297
17298
17299
17300
17301
17302
17303
17304
17305
17306
17307
17308
17309
17310
 
# File 'ext/ctp/ctp.cxx', line 17284

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

#PreCredit(*args) ⇒ Object 



17207
17208
17209
17210
17211
17212
17213
17214
17215
17216
17217
17218
17219
17220
17221
17222
17223
17224
17225
17226
17227
17228
 
# File 'ext/ctp/ctp.cxx', line 17207

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

#PreCredit=(*args) ⇒ Object 



17178
17179
17180
17181
17182
17183
17184
17185
17186
17187
17188
17189
17190
17191
17192
17193
17194
17195
17196
17197
17198
17199
17200
17201
17202
17203
17204
 
# File 'ext/ctp/ctp.cxx', line 17178

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

#PreDeposit(*args) ⇒ Object 



17260
17261
17262
17263
17264
17265
17266
17267
17268
17269
17270
17271
17272
17273
17274
17275
17276
17277
17278
17279
17280
17281
 
# File 'ext/ctp/ctp.cxx', line 17260

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

#PreDeposit=(*args) ⇒ Object 



17231
17232
17233
17234
17235
17236
17237
17238
17239
17240
17241
17242
17243
17244
17245
17246
17247
17248
17249
17250
17251
17252
17253
17254
17255
17256
17257
 
# File 'ext/ctp/ctp.cxx', line 17231

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

#PreFundMortgageIn(*args) ⇒ Object 



18758
18759
18760
18761
18762
18763
18764
18765
18766
18767
18768
18769
18770
18771
18772
18773
18774
18775
18776
18777
18778
18779
 
# File 'ext/ctp/ctp.cxx', line 18758

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

#PreFundMortgageIn=(*args) ⇒ Object 



18729
18730
18731
18732
18733
18734
18735
18736
18737
18738
18739
18740
18741
18742
18743
18744
18745
18746
18747
18748
18749
18750
18751
18752
18753
18754
18755
 
# File 'ext/ctp/ctp.cxx', line 18729

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

#PreFundMortgageOut(*args) ⇒ Object 



18811
18812
18813
18814
18815
18816
18817
18818
18819
18820
18821
18822
18823
18824
18825
18826
18827
18828
18829
18830
18831
18832
 
# File 'ext/ctp/ctp.cxx', line 18811

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

#PreFundMortgageOut=(*args) ⇒ Object 



18782
18783
18784
18785
18786
18787
18788
18789
18790
18791
18792
18793
18794
18795
18796
18797
18798
18799
18800
18801
18802
18803
18804
18805
18806
18807
18808
 
# File 'ext/ctp/ctp.cxx', line 18782

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

#PreMargin(*args) ⇒ Object 



17366
17367
17368
17369
17370
17371
17372
17373
17374
17375
17376
17377
17378
17379
17380
17381
17382
17383
17384
17385
17386
17387
 
# File 'ext/ctp/ctp.cxx', line 17366

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

#PreMargin=(*args) ⇒ Object 



17337
17338
17339
17340
17341
17342
17343
17344
17345
17346
17347
17348
17349
17350
17351
17352
17353
17354
17355
17356
17357
17358
17359
17360
17361
17362
17363
 
# File 'ext/ctp/ctp.cxx', line 17337

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

#PreMortgage(*args) ⇒ Object 



17154
17155
17156
17157
17158
17159
17160
17161
17162
17163
17164
17165
17166
17167
17168
17169
17170
17171
17172
17173
17174
17175
 
# File 'ext/ctp/ctp.cxx', line 17154

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

#PreMortgage=(*args) ⇒ Object 



17125
17126
17127
17128
17129
17130
17131
17132
17133
17134
17135
17136
17137
17138
17139
17140
17141
17142
17143
17144
17145
17146
17147
17148
17149
17150
17151
 
# File 'ext/ctp/ctp.cxx', line 17125

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

#Reserve(*args) ⇒ Object 



18214
18215
18216
18217
18218
18219
18220
18221
18222
18223
18224
18225
18226
18227
18228
18229
18230
18231
18232
18233
18234
18235
 
# File 'ext/ctp/ctp.cxx', line 18214

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

#Reserve=(*args) ⇒ Object 



18185
18186
18187
18188
18189
18190
18191
18192
18193
18194
18195
18196
18197
18198
18199
18200
18201
18202
18203
18204
18205
18206
18207
18208
18209
18210
18211
 
# File 'ext/ctp/ctp.cxx', line 18185

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

#ReserveBalance(*args) ⇒ Object 



18645
18646
18647
18648
18649
18650
18651
18652
18653
18654
18655
18656
18657
18658
18659
18660
18661
18662
18663
18664
18665
18666
 
# File 'ext/ctp/ctp.cxx', line 18645

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

#ReserveBalance=(*args) ⇒ Object 



18616
18617
18618
18619
18620
18621
18622
18623
18624
18625
18626
18627
18628
18629
18630
18631
18632
18633
18634
18635
18636
18637
18638
18639
18640
18641
18642
 
# File 'ext/ctp/ctp.cxx', line 18616

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

#SettlementID(*args) ⇒ Object 



18327
18328
18329
18330
18331
18332
18333
18334
18335
18336
18337
18338
18339
18340
18341
18342
18343
18344
18345
18346
18347
18348
 
# File 'ext/ctp/ctp.cxx', line 18327

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

#SettlementID=(*args) ⇒ Object 



18298
18299
18300
18301
18302
18303
18304
18305
18306
18307
18308
18309
18310
18311
18312
18313
18314
18315
18316
18317
18318
18319
18320
18321
18322
18323
18324
 
# File 'ext/ctp/ctp.cxx', line 18298

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

#SpecProductCloseProfit(*args) ⇒ Object 



19341
19342
19343
19344
19345
19346
19347
19348
19349
19350
19351
19352
19353
19354
19355
19356
19357
19358
19359
19360
19361
19362
 
# File 'ext/ctp/ctp.cxx', line 19341

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

#SpecProductCloseProfit=(*args) ⇒ Object 



19312
19313
19314
19315
19316
19317
19318
19319
19320
19321
19322
19323
19324
19325
19326
19327
19328
19329
19330
19331
19332
19333
19334
19335
19336
19337
19338
 
# File 'ext/ctp/ctp.cxx', line 19312

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

#SpecProductCommission(*args) ⇒ Object 



19182
19183
19184
19185
19186
19187
19188
19189
19190
19191
19192
19193
19194
19195
19196
19197
19198
19199
19200
19201
19202
19203
 
# File 'ext/ctp/ctp.cxx', line 19182

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

#SpecProductCommission=(*args) ⇒ Object 



19153
19154
19155
19156
19157
19158
19159
19160
19161
19162
19163
19164
19165
19166
19167
19168
19169
19170
19171
19172
19173
19174
19175
19176
19177
19178
19179
 
# File 'ext/ctp/ctp.cxx', line 19153

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

#SpecProductExchangeMargin(*args) ⇒ Object 



19447
19448
19449
19450
19451
19452
19453
19454
19455
19456
19457
19458
19459
19460
19461
19462
19463
19464
19465
19466
19467
19468
 
# File 'ext/ctp/ctp.cxx', line 19447

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

#SpecProductExchangeMargin=(*args) ⇒ Object 



19418
19419
19420
19421
19422
19423
19424
19425
19426
19427
19428
19429
19430
19431
19432
19433
19434
19435
19436
19437
19438
19439
19440
19441
19442
19443
19444
 
# File 'ext/ctp/ctp.cxx', line 19418

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

#SpecProductFrozenCommission(*args) ⇒ Object 



19235
19236
19237
19238
19239
19240
19241
19242
19243
19244
19245
19246
19247
19248
19249
19250
19251
19252
19253
19254
19255
19256
 
# File 'ext/ctp/ctp.cxx', line 19235

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

#SpecProductFrozenCommission=(*args) ⇒ Object 



19206
19207
19208
19209
19210
19211
19212
19213
19214
19215
19216
19217
19218
19219
19220
19221
19222
19223
19224
19225
19226
19227
19228
19229
19230
19231
19232
 
# File 'ext/ctp/ctp.cxx', line 19206

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

#SpecProductFrozenMargin(*args) ⇒ Object 



19129
19130
19131
19132
19133
19134
19135
19136
19137
19138
19139
19140
19141
19142
19143
19144
19145
19146
19147
19148
19149
19150
 
# File 'ext/ctp/ctp.cxx', line 19129

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

#SpecProductFrozenMargin=(*args) ⇒ Object 



19100
19101
19102
19103
19104
19105
19106
19107
19108
19109
19110
19111
19112
19113
19114
19115
19116
19117
19118
19119
19120
19121
19122
19123
19124
19125
19126
 
# File 'ext/ctp/ctp.cxx', line 19100

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

#SpecProductMargin(*args) ⇒ Object 



19076
19077
19078
19079
19080
19081
19082
19083
19084
19085
19086
19087
19088
19089
19090
19091
19092
19093
19094
19095
19096
19097
 
# File 'ext/ctp/ctp.cxx', line 19076

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

#SpecProductMargin=(*args) ⇒ Object 



19047
19048
19049
19050
19051
19052
19053
19054
19055
19056
19057
19058
19059
19060
19061
19062
19063
19064
19065
19066
19067
19068
19069
19070
19071
19072
19073
 
# File 'ext/ctp/ctp.cxx', line 19047

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

#SpecProductPositionProfit(*args) ⇒ Object 



19288
19289
19290
19291
19292
19293
19294
19295
19296
19297
19298
19299
19300
19301
19302
19303
19304
19305
19306
19307
19308
19309
 
# File 'ext/ctp/ctp.cxx', line 19288

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

#SpecProductPositionProfit=(*args) ⇒ Object 



19259
19260
19261
19262
19263
19264
19265
19266
19267
19268
19269
19270
19271
19272
19273
19274
19275
19276
19277
19278
19279
19280
19281
19282
19283
19284
19285
 
# File 'ext/ctp/ctp.cxx', line 19259

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

#SpecProductPositionProfitByAlg(*args) ⇒ Object 



19394
19395
19396
19397
19398
19399
19400
19401
19402
19403
19404
19405
19406
19407
19408
19409
19410
19411
19412
19413
19414
19415
 
# File 'ext/ctp/ctp.cxx', line 19394

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

#SpecProductPositionProfitByAlg=(*args) ⇒ Object 



19365
19366
19367
19368
19369
19370
19371
19372
19373
19374
19375
19376
19377
19378
19379
19380
19381
19382
19383
19384
19385
19386
19387
19388
19389
19390
19391
 
# File 'ext/ctp/ctp.cxx', line 19365

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

#TradingDay(*args) ⇒ Object 



18268
18269
18270
18271
18272
18273
18274
18275
18276
18277
18278
18279
18280
18281
18282
18283
18284
18285
18286
18287
18288
18289
18290
18291
18292
18293
18294
18295
 
# File 'ext/ctp/ctp.cxx', line 18268

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



18238
18239
18240
18241
18242
18243
18244
18245
18246
18247
18248
18249
18250
18251
18252
18253
18254
18255
18256
18257
18258
18259
18260
18261
18262
18263
18264
18265
 
# File 'ext/ctp/ctp.cxx', line 18238

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

#Withdraw(*args) ⇒ Object 



17578
17579
17580
17581
17582
17583
17584
17585
17586
17587
17588
17589
17590
17591
17592
17593
17594
17595
17596
17597
17598
17599
 
# File 'ext/ctp/ctp.cxx', line 17578

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

#Withdraw=(*args) ⇒ Object 



17549
17550
17551
17552
17553
17554
17555
17556
17557
17558
17559
17560
17561
17562
17563
17564
17565
17566
17567
17568
17569
17570
17571
17572
17573
17574
17575
 
# File 'ext/ctp/ctp.cxx', line 17549

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

#WithdrawQuota(*args) ⇒ Object 



18161
18162
18163
18164
18165
18166
18167
18168
18169
18170
18171
18172
18173
18174
18175
18176
18177
18178
18179
18180
18181
18182
 
# File 'ext/ctp/ctp.cxx', line 18161

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

#WithdrawQuota=(*args) ⇒ Object 



18132
18133
18134
18135
18136
18137
18138
18139
18140
18141
18142
18143
18144
18145
18146
18147
18148
18149
18150
18151
18152
18153
18154
18155
18156
18157
18158
 
# File 'ext/ctp/ctp.cxx', line 18132

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