Class: Ctp::CThostFtdcExchangeMarginRateAdjustField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



29971
29972
29973
29974
29975
29976
29977
29978
29979
29980
29981
29982
29983
29984
 
# File 'ext/ctp/ctp.cxx', line 29971

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

Instance Method Details

#BrokerID(*args) ⇒ Object 



29177
29178
29179
29180
29181
29182
29183
29184
29185
29186
29187
29188
29189
29190
29191
29192
29193
29194
29195
29196
29197
29198
29199
29200
29201
29202
29203
29204
 
# File 'ext/ctp/ctp.cxx', line 29177

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



29147
29148
29149
29150
29151
29152
29153
29154
29155
29156
29157
29158
29159
29160
29161
29162
29163
29164
29165
29166
29167
29168
29169
29170
29171
29172
29173
29174
 
# File 'ext/ctp/ctp.cxx', line 29147

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

#ExchLongMarginRatioByMoney(*args) ⇒ Object 



29561
29562
29563
29564
29565
29566
29567
29568
29569
29570
29571
29572
29573
29574
29575
29576
29577
29578
29579
29580
29581
29582
 
# File 'ext/ctp/ctp.cxx', line 29561

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

#ExchLongMarginRatioByMoney=(*args) ⇒ Object 



29532
29533
29534
29535
29536
29537
29538
29539
29540
29541
29542
29543
29544
29545
29546
29547
29548
29549
29550
29551
29552
29553
29554
29555
29556
29557
29558
 
# File 'ext/ctp/ctp.cxx', line 29532

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

#ExchLongMarginRatioByVolume(*args) ⇒ Object 



29614
29615
29616
29617
29618
29619
29620
29621
29622
29623
29624
29625
29626
29627
29628
29629
29630
29631
29632
29633
29634
29635
 
# File 'ext/ctp/ctp.cxx', line 29614

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

#ExchLongMarginRatioByVolume=(*args) ⇒ Object 



29585
29586
29587
29588
29589
29590
29591
29592
29593
29594
29595
29596
29597
29598
29599
29600
29601
29602
29603
29604
29605
29606
29607
29608
29609
29610
29611
 
# File 'ext/ctp/ctp.cxx', line 29585

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

#ExchShortMarginRatioByMoney(*args) ⇒ Object 



29667
29668
29669
29670
29671
29672
29673
29674
29675
29676
29677
29678
29679
29680
29681
29682
29683
29684
29685
29686
29687
29688
 
# File 'ext/ctp/ctp.cxx', line 29667

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

#ExchShortMarginRatioByMoney=(*args) ⇒ Object 



29638
29639
29640
29641
29642
29643
29644
29645
29646
29647
29648
29649
29650
29651
29652
29653
29654
29655
29656
29657
29658
29659
29660
29661
29662
29663
29664
 
# File 'ext/ctp/ctp.cxx', line 29638

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

#ExchShortMarginRatioByVolume(*args) ⇒ Object 



29720
29721
29722
29723
29724
29725
29726
29727
29728
29729
29730
29731
29732
29733
29734
29735
29736
29737
29738
29739
29740
29741
 
# File 'ext/ctp/ctp.cxx', line 29720

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

#ExchShortMarginRatioByVolume=(*args) ⇒ Object 



29691
29692
29693
29694
29695
29696
29697
29698
29699
29700
29701
29702
29703
29704
29705
29706
29707
29708
29709
29710
29711
29712
29713
29714
29715
29716
29717
 
# File 'ext/ctp/ctp.cxx', line 29691

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

#HedgeFlag(*args) ⇒ Object 



29296
29297
29298
29299
29300
29301
29302
29303
29304
29305
29306
29307
29308
29309
29310
29311
29312
29313
29314
29315
29316
29317
 
# File 'ext/ctp/ctp.cxx', line 29296

SWIGINTERN VALUE
_wrap_CThostFtdcExchangeMarginRateAdjustField_HedgeFlag_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcExchangeMarginRateAdjustField *arg1 = (CThostFtdcExchangeMarginRateAdjustField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcHedgeFlagType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcExchangeMarginRateAdjustField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcExchangeMarginRateAdjustField *","HedgeFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcExchangeMarginRateAdjustField * >(argp1);
  result = (TThostFtdcHedgeFlagType) ((arg1)->HedgeFlag);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#HedgeFlag=(*args) ⇒ Object 



29267
29268
29269
29270
29271
29272
29273
29274
29275
29276
29277
29278
29279
29280
29281
29282
29283
29284
29285
29286
29287
29288
29289
29290
29291
29292
29293
 
# File 'ext/ctp/ctp.cxx', line 29267

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

#InstrumentID(*args) ⇒ Object 



29237
29238
29239
29240
29241
29242
29243
29244
29245
29246
29247
29248
29249
29250
29251
29252
29253
29254
29255
29256
29257
29258
29259
29260
29261
29262
29263
29264
 
# File 'ext/ctp/ctp.cxx', line 29237

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

#InstrumentID=(*args) ⇒ Object 



29207
29208
29209
29210
29211
29212
29213
29214
29215
29216
29217
29218
29219
29220
29221
29222
29223
29224
29225
29226
29227
29228
29229
29230
29231
29232
29233
29234
 
# File 'ext/ctp/ctp.cxx', line 29207

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

#LongMarginRatioByMoney(*args) ⇒ Object 



29349
29350
29351
29352
29353
29354
29355
29356
29357
29358
29359
29360
29361
29362
29363
29364
29365
29366
29367
29368
29369
29370
 
# File 'ext/ctp/ctp.cxx', line 29349

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

#LongMarginRatioByMoney=(*args) ⇒ Object 



29320
29321
29322
29323
29324
29325
29326
29327
29328
29329
29330
29331
29332
29333
29334
29335
29336
29337
29338
29339
29340
29341
29342
29343
29344
29345
29346
 
# File 'ext/ctp/ctp.cxx', line 29320

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

#LongMarginRatioByVolume(*args) ⇒ Object 



29402
29403
29404
29405
29406
29407
29408
29409
29410
29411
29412
29413
29414
29415
29416
29417
29418
29419
29420
29421
29422
29423
 
# File 'ext/ctp/ctp.cxx', line 29402

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

#LongMarginRatioByVolume=(*args) ⇒ Object 



29373
29374
29375
29376
29377
29378
29379
29380
29381
29382
29383
29384
29385
29386
29387
29388
29389
29390
29391
29392
29393
29394
29395
29396
29397
29398
29399
 
# File 'ext/ctp/ctp.cxx', line 29373

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

#NoLongMarginRatioByMoney(*args) ⇒ Object 



29773
29774
29775
29776
29777
29778
29779
29780
29781
29782
29783
29784
29785
29786
29787
29788
29789
29790
29791
29792
29793
29794
 
# File 'ext/ctp/ctp.cxx', line 29773

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

#NoLongMarginRatioByMoney=(*args) ⇒ Object 



29744
29745
29746
29747
29748
29749
29750
29751
29752
29753
29754
29755
29756
29757
29758
29759
29760
29761
29762
29763
29764
29765
29766
29767
29768
29769
29770
 
# File 'ext/ctp/ctp.cxx', line 29744

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

#NoLongMarginRatioByVolume(*args) ⇒ Object 



29826
29827
29828
29829
29830
29831
29832
29833
29834
29835
29836
29837
29838
29839
29840
29841
29842
29843
29844
29845
29846
29847
 
# File 'ext/ctp/ctp.cxx', line 29826

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

#NoLongMarginRatioByVolume=(*args) ⇒ Object 



29797
29798
29799
29800
29801
29802
29803
29804
29805
29806
29807
29808
29809
29810
29811
29812
29813
29814
29815
29816
29817
29818
29819
29820
29821
29822
29823
 
# File 'ext/ctp/ctp.cxx', line 29797

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

#NoShortMarginRatioByMoney(*args) ⇒ Object 



29879
29880
29881
29882
29883
29884
29885
29886
29887
29888
29889
29890
29891
29892
29893
29894
29895
29896
29897
29898
29899
29900
 
# File 'ext/ctp/ctp.cxx', line 29879

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

#NoShortMarginRatioByMoney=(*args) ⇒ Object 



29850
29851
29852
29853
29854
29855
29856
29857
29858
29859
29860
29861
29862
29863
29864
29865
29866
29867
29868
29869
29870
29871
29872
29873
29874
29875
29876
 
# File 'ext/ctp/ctp.cxx', line 29850

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

#NoShortMarginRatioByVolume(*args) ⇒ Object 



29932
29933
29934
29935
29936
29937
29938
29939
29940
29941
29942
29943
29944
29945
29946
29947
29948
29949
29950
29951
29952
29953
 
# File 'ext/ctp/ctp.cxx', line 29932

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

#NoShortMarginRatioByVolume=(*args) ⇒ Object 



29903
29904
29905
29906
29907
29908
29909
29910
29911
29912
29913
29914
29915
29916
29917
29918
29919
29920
29921
29922
29923
29924
29925
29926
29927
29928
29929
 
# File 'ext/ctp/ctp.cxx', line 29903

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

#ShortMarginRatioByMoney(*args) ⇒ Object 



29455
29456
29457
29458
29459
29460
29461
29462
29463
29464
29465
29466
29467
29468
29469
29470
29471
29472
29473
29474
29475
29476
 
# File 'ext/ctp/ctp.cxx', line 29455

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

#ShortMarginRatioByMoney=(*args) ⇒ Object 



29426
29427
29428
29429
29430
29431
29432
29433
29434
29435
29436
29437
29438
29439
29440
29441
29442
29443
29444
29445
29446
29447
29448
29449
29450
29451
29452
 
# File 'ext/ctp/ctp.cxx', line 29426

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

#ShortMarginRatioByVolume(*args) ⇒ Object 



29508
29509
29510
29511
29512
29513
29514
29515
29516
29517
29518
29519
29520
29521
29522
29523
29524
29525
29526
29527
29528
29529
 
# File 'ext/ctp/ctp.cxx', line 29508

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

#ShortMarginRatioByVolume=(*args) ⇒ Object 



29479
29480
29481
29482
29483
29484
29485
29486
29487
29488
29489
29490
29491
29492
29493
29494
29495
29496
29497
29498
29499
29500
29501
29502
29503
29504
29505
 
# File 'ext/ctp/ctp.cxx', line 29479

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