Class: Ctp::CThostFtdcBrokerWithdrawAlgorithmField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



108360
108361
108362
108363
108364
108365
108366
108367
108368
108369
108370
108371
108372
108373
 
# File 'ext/ctp/ctp.cxx', line 108360

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

Instance Method Details

#AllWithoutTrade(*args) ⇒ Object 



108049
108050
108051
108052
108053
108054
108055
108056
108057
108058
108059
108060
108061
108062
108063
108064
108065
108066
108067
108068
108069
108070
 
# File 'ext/ctp/ctp.cxx', line 108049

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

#AllWithoutTrade=(*args) ⇒ Object 



108020
108021
108022
108023
108024
108025
108026
108027
108028
108029
108030
108031
108032
108033
108034
108035
108036
108037
108038
108039
108040
108041
108042
108043
108044
108045
108046
 
# File 'ext/ctp/ctp.cxx', line 108020

SWIGINTERN VALUE
_wrap_CThostFtdcBrokerWithdrawAlgorithmField_AllWithoutTrade_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcBrokerWithdrawAlgorithmField *arg1 = (CThostFtdcBrokerWithdrawAlgorithmField *) 0 ;
  TThostFtdcAllWithoutTradeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcBrokerWithdrawAlgorithmField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcBrokerWithdrawAlgorithmField *","AllWithoutTrade", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcBrokerWithdrawAlgorithmField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcAllWithoutTradeType","AllWithoutTrade", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcAllWithoutTradeType >(val2);
  if (arg1) (arg1)->AllWithoutTrade = arg2;
  return Qnil;
fail:
  return Qnil;
}

#AvailIncludeCloseProfit(*args) ⇒ Object 



108102
108103
108104
108105
108106
108107
108108
108109
108110
108111
108112
108113
108114
108115
108116
108117
108118
108119
108120
108121
108122
108123
 
# File 'ext/ctp/ctp.cxx', line 108102

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

#AvailIncludeCloseProfit=(*args) ⇒ Object 



108073
108074
108075
108076
108077
108078
108079
108080
108081
108082
108083
108084
108085
108086
108087
108088
108089
108090
108091
108092
108093
108094
108095
108096
108097
108098
108099
 
# File 'ext/ctp/ctp.cxx', line 108073

SWIGINTERN VALUE
_wrap_CThostFtdcBrokerWithdrawAlgorithmField_AvailIncludeCloseProfit_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcBrokerWithdrawAlgorithmField *arg1 = (CThostFtdcBrokerWithdrawAlgorithmField *) 0 ;
  TThostFtdcIncludeCloseProfitType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcBrokerWithdrawAlgorithmField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcBrokerWithdrawAlgorithmField *","AvailIncludeCloseProfit", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcBrokerWithdrawAlgorithmField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcIncludeCloseProfitType","AvailIncludeCloseProfit", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcIncludeCloseProfitType >(val2);
  if (arg1) (arg1)->AvailIncludeCloseProfit = arg2;
  return Qnil;
fail:
  return Qnil;
}

#BalanceAlgorithm(*args) ⇒ Object 



108321
108322
108323
108324
108325
108326
108327
108328
108329
108330
108331
108332
108333
108334
108335
108336
108337
108338
108339
108340
108341
108342
 
# File 'ext/ctp/ctp.cxx', line 108321

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

#BalanceAlgorithm=(*args) ⇒ Object 



108292
108293
108294
108295
108296
108297
108298
108299
108300
108301
108302
108303
108304
108305
108306
108307
108308
108309
108310
108311
108312
108313
108314
108315
108316
108317
108318
 
# File 'ext/ctp/ctp.cxx', line 108292

SWIGINTERN VALUE
_wrap_CThostFtdcBrokerWithdrawAlgorithmField_BalanceAlgorithm_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcBrokerWithdrawAlgorithmField *arg1 = (CThostFtdcBrokerWithdrawAlgorithmField *) 0 ;
  TThostFtdcBalanceAlgorithmType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcBrokerWithdrawAlgorithmField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcBrokerWithdrawAlgorithmField *","BalanceAlgorithm", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcBrokerWithdrawAlgorithmField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcBalanceAlgorithmType","BalanceAlgorithm", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcBalanceAlgorithmType >(val2);
  if (arg1) (arg1)->BalanceAlgorithm = arg2;
  return Qnil;
fail:
  return Qnil;
}

#BrokerID(*args) ⇒ Object 



107831
107832
107833
107834
107835
107836
107837
107838
107839
107840
107841
107842
107843
107844
107845
107846
107847
107848
107849
107850
107851
107852
107853
107854
107855
107856
107857
107858
 
# File 'ext/ctp/ctp.cxx', line 107831

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



107801
107802
107803
107804
107805
107806
107807
107808
107809
107810
107811
107812
107813
107814
107815
107816
107817
107818
107819
107820
107821
107822
107823
107824
107825
107826
107827
107828
 
# File 'ext/ctp/ctp.cxx', line 107801

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

#CurrencyID(*args) ⇒ Object 



108209
108210
108211
108212
108213
108214
108215
108216
108217
108218
108219
108220
108221
108222
108223
108224
108225
108226
108227
108228
108229
108230
108231
108232
108233
108234
108235
108236
 
# File 'ext/ctp/ctp.cxx', line 108209

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



108179
108180
108181
108182
108183
108184
108185
108186
108187
108188
108189
108190
108191
108192
108193
108194
108195
108196
108197
108198
108199
108200
108201
108202
108203
108204
108205
108206
 
# File 'ext/ctp/ctp.cxx', line 108179

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

#FundMortgageRatio(*args) ⇒ Object 



108268
108269
108270
108271
108272
108273
108274
108275
108276
108277
108278
108279
108280
108281
108282
108283
108284
108285
108286
108287
108288
108289
 
# File 'ext/ctp/ctp.cxx', line 108268

SWIGINTERN VALUE
_wrap_CThostFtdcBrokerWithdrawAlgorithmField_FundMortgageRatio_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcBrokerWithdrawAlgorithmField *arg1 = (CThostFtdcBrokerWithdrawAlgorithmField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcRatioType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcBrokerWithdrawAlgorithmField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcBrokerWithdrawAlgorithmField *","FundMortgageRatio", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcBrokerWithdrawAlgorithmField * >(argp1);
  result = (TThostFtdcRatioType) ((arg1)->FundMortgageRatio);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#FundMortgageRatio=(*args) ⇒ Object 



108239
108240
108241
108242
108243
108244
108245
108246
108247
108248
108249
108250
108251
108252
108253
108254
108255
108256
108257
108258
108259
108260
108261
108262
108263
108264
108265
 
# File 'ext/ctp/ctp.cxx', line 108239

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

#IncludeCloseProfit(*args) ⇒ Object 



107996
107997
107998
107999
108000
108001
108002
108003
108004
108005
108006
108007
108008
108009
108010
108011
108012
108013
108014
108015
108016
108017
 
# File 'ext/ctp/ctp.cxx', line 107996

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

#IncludeCloseProfit=(*args) ⇒ Object 



107967
107968
107969
107970
107971
107972
107973
107974
107975
107976
107977
107978
107979
107980
107981
107982
107983
107984
107985
107986
107987
107988
107989
107990
107991
107992
107993
 
# File 'ext/ctp/ctp.cxx', line 107967

SWIGINTERN VALUE
_wrap_CThostFtdcBrokerWithdrawAlgorithmField_IncludeCloseProfit_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcBrokerWithdrawAlgorithmField *arg1 = (CThostFtdcBrokerWithdrawAlgorithmField *) 0 ;
  TThostFtdcIncludeCloseProfitType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcBrokerWithdrawAlgorithmField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcBrokerWithdrawAlgorithmField *","IncludeCloseProfit", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcBrokerWithdrawAlgorithmField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcIncludeCloseProfitType","IncludeCloseProfit", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcIncludeCloseProfitType >(val2);
  if (arg1) (arg1)->IncludeCloseProfit = arg2;
  return Qnil;
fail:
  return Qnil;
}

#IsBrokerUserEvent(*args) ⇒ Object 



108155
108156
108157
108158
108159
108160
108161
108162
108163
108164
108165
108166
108167
108168
108169
108170
108171
108172
108173
108174
108175
108176
 
# File 'ext/ctp/ctp.cxx', line 108155

SWIGINTERN VALUE
_wrap_CThostFtdcBrokerWithdrawAlgorithmField_IsBrokerUserEvent_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcBrokerWithdrawAlgorithmField *arg1 = (CThostFtdcBrokerWithdrawAlgorithmField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcBoolType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcBrokerWithdrawAlgorithmField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcBrokerWithdrawAlgorithmField *","IsBrokerUserEvent", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcBrokerWithdrawAlgorithmField * >(argp1);
  result = (TThostFtdcBoolType) ((arg1)->IsBrokerUserEvent);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#IsBrokerUserEvent=(*args) ⇒ Object 



108126
108127
108128
108129
108130
108131
108132
108133
108134
108135
108136
108137
108138
108139
108140
108141
108142
108143
108144
108145
108146
108147
108148
108149
108150
108151
108152
 
# File 'ext/ctp/ctp.cxx', line 108126

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

#UsingRatio(*args) ⇒ Object 



107943
107944
107945
107946
107947
107948
107949
107950
107951
107952
107953
107954
107955
107956
107957
107958
107959
107960
107961
107962
107963
107964
 
# File 'ext/ctp/ctp.cxx', line 107943

SWIGINTERN VALUE
_wrap_CThostFtdcBrokerWithdrawAlgorithmField_UsingRatio_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcBrokerWithdrawAlgorithmField *arg1 = (CThostFtdcBrokerWithdrawAlgorithmField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcRatioType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcBrokerWithdrawAlgorithmField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcBrokerWithdrawAlgorithmField *","UsingRatio", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcBrokerWithdrawAlgorithmField * >(argp1);
  result = (TThostFtdcRatioType) ((arg1)->UsingRatio);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#UsingRatio=(*args) ⇒ Object 



107914
107915
107916
107917
107918
107919
107920
107921
107922
107923
107924
107925
107926
107927
107928
107929
107930
107931
107932
107933
107934
107935
107936
107937
107938
107939
107940
 
# File 'ext/ctp/ctp.cxx', line 107914

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

#WithdrawAlgorithm(*args) ⇒ Object 



107890
107891
107892
107893
107894
107895
107896
107897
107898
107899
107900
107901
107902
107903
107904
107905
107906
107907
107908
107909
107910
107911
 
# File 'ext/ctp/ctp.cxx', line 107890

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

#WithdrawAlgorithm=(*args) ⇒ Object 



107861
107862
107863
107864
107865
107866
107867
107868
107869
107870
107871
107872
107873
107874
107875
107876
107877
107878
107879
107880
107881
107882
107883
107884
107885
107886
107887
 
# File 'ext/ctp/ctp.cxx', line 107861

SWIGINTERN VALUE
_wrap_CThostFtdcBrokerWithdrawAlgorithmField_WithdrawAlgorithm_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcBrokerWithdrawAlgorithmField *arg1 = (CThostFtdcBrokerWithdrawAlgorithmField *) 0 ;
  TThostFtdcAlgorithmType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcBrokerWithdrawAlgorithmField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcBrokerWithdrawAlgorithmField *","WithdrawAlgorithm", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcBrokerWithdrawAlgorithmField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TThostFtdcAlgorithmType","WithdrawAlgorithm", 2, argv[0] ));
  } 
  arg2 = static_cast< TThostFtdcAlgorithmType >(val2);
  if (arg1) (arg1)->WithdrawAlgorithm = arg2;
  return Qnil;
fail:
  return Qnil;
}