Class: Ctp::CThostFtdcOptionInstrTradeCostField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



67005
67006
67007
67008
67009
67010
67011
67012
67013
67014
67015
67016
67017
67018
 
# File 'ext/ctp/ctp.cxx', line 67005

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

Instance Method Details

#BrokerID(*args) ⇒ Object 



66522
66523
66524
66525
66526
66527
66528
66529
66530
66531
66532
66533
66534
66535
66536
66537
66538
66539
66540
66541
66542
66543
66544
66545
66546
66547
66548
66549
 
# File 'ext/ctp/ctp.cxx', line 66522

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



66492
66493
66494
66495
66496
66497
66498
66499
66500
66501
66502
66503
66504
66505
66506
66507
66508
66509
66510
66511
66512
66513
66514
66515
66516
66517
66518
66519
 
# File 'ext/ctp/ctp.cxx', line 66492

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

#ExchFixedMargin(*args) ⇒ Object 



66913
66914
66915
66916
66917
66918
66919
66920
66921
66922
66923
66924
66925
66926
66927
66928
66929
66930
66931
66932
66933
66934
 
# File 'ext/ctp/ctp.cxx', line 66913

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

#ExchFixedMargin=(*args) ⇒ Object 



66884
66885
66886
66887
66888
66889
66890
66891
66892
66893
66894
66895
66896
66897
66898
66899
66900
66901
66902
66903
66904
66905
66906
66907
66908
66909
66910
 
# File 'ext/ctp/ctp.cxx', line 66884

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

#ExchMiniMargin(*args) ⇒ Object 



66966
66967
66968
66969
66970
66971
66972
66973
66974
66975
66976
66977
66978
66979
66980
66981
66982
66983
66984
66985
66986
66987
 
# File 'ext/ctp/ctp.cxx', line 66966

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

#ExchMiniMargin=(*args) ⇒ Object 



66937
66938
66939
66940
66941
66942
66943
66944
66945
66946
66947
66948
66949
66950
66951
66952
66953
66954
66955
66956
66957
66958
66959
66960
66961
66962
66963
 
# File 'ext/ctp/ctp.cxx', line 66937

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

#FixedMargin(*args) ⇒ Object 



66754
66755
66756
66757
66758
66759
66760
66761
66762
66763
66764
66765
66766
66767
66768
66769
66770
66771
66772
66773
66774
66775
 
# File 'ext/ctp/ctp.cxx', line 66754

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

#FixedMargin=(*args) ⇒ Object 



66725
66726
66727
66728
66729
66730
66731
66732
66733
66734
66735
66736
66737
66738
66739
66740
66741
66742
66743
66744
66745
66746
66747
66748
66749
66750
66751
 
# File 'ext/ctp/ctp.cxx', line 66725

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

#HedgeFlag(*args) ⇒ Object 



66701
66702
66703
66704
66705
66706
66707
66708
66709
66710
66711
66712
66713
66714
66715
66716
66717
66718
66719
66720
66721
66722
 
# File 'ext/ctp/ctp.cxx', line 66701

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

#HedgeFlag=(*args) ⇒ Object 



66672
66673
66674
66675
66676
66677
66678
66679
66680
66681
66682
66683
66684
66685
66686
66687
66688
66689
66690
66691
66692
66693
66694
66695
66696
66697
66698
 
# File 'ext/ctp/ctp.cxx', line 66672

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



66642
66643
66644
66645
66646
66647
66648
66649
66650
66651
66652
66653
66654
66655
66656
66657
66658
66659
66660
66661
66662
66663
66664
66665
66666
66667
66668
66669
 
# File 'ext/ctp/ctp.cxx', line 66642

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



66612
66613
66614
66615
66616
66617
66618
66619
66620
66621
66622
66623
66624
66625
66626
66627
66628
66629
66630
66631
66632
66633
66634
66635
66636
66637
66638
66639
 
# File 'ext/ctp/ctp.cxx', line 66612

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

#InvestorID(*args) ⇒ Object 



66582
66583
66584
66585
66586
66587
66588
66589
66590
66591
66592
66593
66594
66595
66596
66597
66598
66599
66600
66601
66602
66603
66604
66605
66606
66607
66608
66609
 
# File 'ext/ctp/ctp.cxx', line 66582

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

#InvestorID=(*args) ⇒ Object 



66552
66553
66554
66555
66556
66557
66558
66559
66560
66561
66562
66563
66564
66565
66566
66567
66568
66569
66570
66571
66572
66573
66574
66575
66576
66577
66578
66579
 
# File 'ext/ctp/ctp.cxx', line 66552

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

#MiniMargin(*args) ⇒ Object 



66807
66808
66809
66810
66811
66812
66813
66814
66815
66816
66817
66818
66819
66820
66821
66822
66823
66824
66825
66826
66827
66828
 
# File 'ext/ctp/ctp.cxx', line 66807

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

#MiniMargin=(*args) ⇒ Object 



66778
66779
66780
66781
66782
66783
66784
66785
66786
66787
66788
66789
66790
66791
66792
66793
66794
66795
66796
66797
66798
66799
66800
66801
66802
66803
66804
 
# File 'ext/ctp/ctp.cxx', line 66778

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

#Royalty(*args) ⇒ Object 



66860
66861
66862
66863
66864
66865
66866
66867
66868
66869
66870
66871
66872
66873
66874
66875
66876
66877
66878
66879
66880
66881
 
# File 'ext/ctp/ctp.cxx', line 66860

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

#Royalty=(*args) ⇒ Object 



66831
66832
66833
66834
66835
66836
66837
66838
66839
66840
66841
66842
66843
66844
66845
66846
66847
66848
66849
66850
66851
66852
66853
66854
66855
66856
66857
 
# File 'ext/ctp/ctp.cxx', line 66831

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