Class: Ctp::CThostFtdcExchangeExecOrderField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



75004
75005
75006
75007
75008
75009
75010
75011
75012
75013
75014
75015
75016
75017
 
# File 'ext/ctp/ctp.cxx', line 75004

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

Instance Method Details

#ActionType(*args) ⇒ Object 



73768
73769
73770
73771
73772
73773
73774
73775
73776
73777
73778
73779
73780
73781
73782
73783
73784
73785
73786
73787
73788
73789
 
# File 'ext/ctp/ctp.cxx', line 73768

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

#ActionType=(*args) ⇒ Object 



73739
73740
73741
73742
73743
73744
73745
73746
73747
73748
73749
73750
73751
73752
73753
73754
73755
73756
73757
73758
73759
73760
73761
73762
73763
73764
73765
 
# File 'ext/ctp/ctp.cxx', line 73739

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

#BusinessUnit(*args) ⇒ Object 



73603
73604
73605
73606
73607
73608
73609
73610
73611
73612
73613
73614
73615
73616
73617
73618
73619
73620
73621
73622
73623
73624
73625
73626
73627
73628
73629
73630
 
# File 'ext/ctp/ctp.cxx', line 73603

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

#BusinessUnit=(*args) ⇒ Object 



73573
73574
73575
73576
73577
73578
73579
73580
73581
73582
73583
73584
73585
73586
73587
73588
73589
73590
73591
73592
73593
73594
73595
73596
73597
73598
73599
73600
 
# File 'ext/ctp/ctp.cxx', line 73573

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

#CancelTime(*args) ⇒ Object 



74793
74794
74795
74796
74797
74798
74799
74800
74801
74802
74803
74804
74805
74806
74807
74808
74809
74810
74811
74812
74813
74814
74815
74816
74817
74818
74819
74820
 
# File 'ext/ctp/ctp.cxx', line 74793

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

#CancelTime=(*args) ⇒ Object 



74763
74764
74765
74766
74767
74768
74769
74770
74771
74772
74773
74774
74775
74776
74777
74778
74779
74780
74781
74782
74783
74784
74785
74786
74787
74788
74789
74790
 
# File 'ext/ctp/ctp.cxx', line 74763

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

#ClearingPartID(*args) ⇒ Object 



74906
74907
74908
74909
74910
74911
74912
74913
74914
74915
74916
74917
74918
74919
74920
74921
74922
74923
74924
74925
74926
74927
74928
74929
74930
74931
74932
74933
 
# File 'ext/ctp/ctp.cxx', line 74906

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

#ClearingPartID=(*args) ⇒ Object 



74876
74877
74878
74879
74880
74881
74882
74883
74884
74885
74886
74887
74888
74889
74890
74891
74892
74893
74894
74895
74896
74897
74898
74899
74900
74901
74902
74903
 
# File 'ext/ctp/ctp.cxx', line 74876

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

#ClientID(*args) ⇒ Object 



74161
74162
74163
74164
74165
74166
74167
74168
74169
74170
74171
74172
74173
74174
74175
74176
74177
74178
74179
74180
74181
74182
74183
74184
74185
74186
74187
74188
 
# File 'ext/ctp/ctp.cxx', line 74161

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

#ClientID=(*args) ⇒ Object 



74131
74132
74133
74134
74135
74136
74137
74138
74139
74140
74141
74142
74143
74144
74145
74146
74147
74148
74149
74150
74151
74152
74153
74154
74155
74156
74157
74158
 
# File 'ext/ctp/ctp.cxx', line 74131

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

#CloseFlag(*args) ⇒ Object 



73927
73928
73929
73930
73931
73932
73933
73934
73935
73936
73937
73938
73939
73940
73941
73942
73943
73944
73945
73946
73947
73948
 
# File 'ext/ctp/ctp.cxx', line 73927

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

#CloseFlag=(*args) ⇒ Object 



73898
73899
73900
73901
73902
73903
73904
73905
73906
73907
73908
73909
73910
73911
73912
73913
73914
73915
73916
73917
73918
73919
73920
73921
73922
73923
73924
 
# File 'ext/ctp/ctp.cxx', line 73898

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

#ExchangeID(*args) ⇒ Object 



74041
74042
74043
74044
74045
74046
74047
74048
74049
74050
74051
74052
74053
74054
74055
74056
74057
74058
74059
74060
74061
74062
74063
74064
74065
74066
74067
74068
 
# File 'ext/ctp/ctp.cxx', line 74041

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

#ExchangeID=(*args) ⇒ Object 



74011
74012
74013
74014
74015
74016
74017
74018
74019
74020
74021
74022
74023
74024
74025
74026
74027
74028
74029
74030
74031
74032
74033
74034
74035
74036
74037
74038
 
# File 'ext/ctp/ctp.cxx', line 74011

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

#ExchangeInstID(*args) ⇒ Object 



74221
74222
74223
74224
74225
74226
74227
74228
74229
74230
74231
74232
74233
74234
74235
74236
74237
74238
74239
74240
74241
74242
74243
74244
74245
74246
74247
74248
 
# File 'ext/ctp/ctp.cxx', line 74221

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

#ExchangeInstID=(*args) ⇒ Object 



74191
74192
74193
74194
74195
74196
74197
74198
74199
74200
74201
74202
74203
74204
74205
74206
74207
74208
74209
74210
74211
74212
74213
74214
74215
74216
74217
74218
 
# File 'ext/ctp/ctp.cxx', line 74191

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

#ExecOrderLocalID(*args) ⇒ Object 



73981
73982
73983
73984
73985
73986
73987
73988
73989
73990
73991
73992
73993
73994
73995
73996
73997
73998
73999
74000
74001
74002
74003
74004
74005
74006
74007
74008
 
# File 'ext/ctp/ctp.cxx', line 73981

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

#ExecOrderLocalID=(*args) ⇒ Object 



73951
73952
73953
73954
73955
73956
73957
73958
73959
73960
73961
73962
73963
73964
73965
73966
73967
73968
73969
73970
73971
73972
73973
73974
73975
73976
73977
73978
 
# File 'ext/ctp/ctp.cxx', line 73951

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

#ExecOrderSysID(*args) ⇒ Object 



74613
74614
74615
74616
74617
74618
74619
74620
74621
74622
74623
74624
74625
74626
74627
74628
74629
74630
74631
74632
74633
74634
74635
74636
74637
74638
74639
74640
 
# File 'ext/ctp/ctp.cxx', line 74613

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

#ExecOrderSysID=(*args) ⇒ Object 



74583
74584
74585
74586
74587
74588
74589
74590
74591
74592
74593
74594
74595
74596
74597
74598
74599
74600
74601
74602
74603
74604
74605
74606
74607
74608
74609
74610
 
# File 'ext/ctp/ctp.cxx', line 74583

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

#ExecResult(*args) ⇒ Object 



74852
74853
74854
74855
74856
74857
74858
74859
74860
74861
74862
74863
74864
74865
74866
74867
74868
74869
74870
74871
74872
74873
 
# File 'ext/ctp/ctp.cxx', line 74852

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

#ExecResult=(*args) ⇒ Object 



74823
74824
74825
74826
74827
74828
74829
74830
74831
74832
74833
74834
74835
74836
74837
74838
74839
74840
74841
74842
74843
74844
74845
74846
74847
74848
74849
 
# File 'ext/ctp/ctp.cxx', line 74823

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

#HedgeFlag(*args) ⇒ Object 



73715
73716
73717
73718
73719
73720
73721
73722
73723
73724
73725
73726
73727
73728
73729
73730
73731
73732
73733
73734
73735
73736
 
# File 'ext/ctp/ctp.cxx', line 73715

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

#HedgeFlag=(*args) ⇒ Object 



73686
73687
73688
73689
73690
73691
73692
73693
73694
73695
73696
73697
73698
73699
73700
73701
73702
73703
73704
73705
73706
73707
73708
73709
73710
73711
73712
 
# File 'ext/ctp/ctp.cxx', line 73686

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

#InsertDate(*args) ⇒ Object 



74673
74674
74675
74676
74677
74678
74679
74680
74681
74682
74683
74684
74685
74686
74687
74688
74689
74690
74691
74692
74693
74694
74695
74696
74697
74698
74699
74700
 
# File 'ext/ctp/ctp.cxx', line 74673

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

#InsertDate=(*args) ⇒ Object 



74643
74644
74645
74646
74647
74648
74649
74650
74651
74652
74653
74654
74655
74656
74657
74658
74659
74660
74661
74662
74663
74664
74665
74666
74667
74668
74669
74670
 
# File 'ext/ctp/ctp.cxx', line 74643

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

#InsertTime(*args) ⇒ Object 



74733
74734
74735
74736
74737
74738
74739
74740
74741
74742
74743
74744
74745
74746
74747
74748
74749
74750
74751
74752
74753
74754
74755
74756
74757
74758
74759
74760
 
# File 'ext/ctp/ctp.cxx', line 74733

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

#InsertTime=(*args) ⇒ Object 



74703
74704
74705
74706
74707
74708
74709
74710
74711
74712
74713
74714
74715
74716
74717
74718
74719
74720
74721
74722
74723
74724
74725
74726
74727
74728
74729
74730
 
# File 'ext/ctp/ctp.cxx', line 74703

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

#InstallID(*args) ⇒ Object 



74340
74341
74342
74343
74344
74345
74346
74347
74348
74349
74350
74351
74352
74353
74354
74355
74356
74357
74358
74359
74360
74361
 
# File 'ext/ctp/ctp.cxx', line 74340

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

#InstallID=(*args) ⇒ Object 



74311
74312
74313
74314
74315
74316
74317
74318
74319
74320
74321
74322
74323
74324
74325
74326
74327
74328
74329
74330
74331
74332
74333
74334
74335
74336
74337
 
# File 'ext/ctp/ctp.cxx', line 74311

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

#NotifySequence(*args) ⇒ Object 



74446
74447
74448
74449
74450
74451
74452
74453
74454
74455
74456
74457
74458
74459
74460
74461
74462
74463
74464
74465
74466
74467
 
# File 'ext/ctp/ctp.cxx', line 74446

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

#NotifySequence=(*args) ⇒ Object 



74417
74418
74419
74420
74421
74422
74423
74424
74425
74426
74427
74428
74429
74430
74431
74432
74433
74434
74435
74436
74437
74438
74439
74440
74441
74442
74443
 
# File 'ext/ctp/ctp.cxx', line 74417

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

#OffsetFlag(*args) ⇒ Object 



73662
73663
73664
73665
73666
73667
73668
73669
73670
73671
73672
73673
73674
73675
73676
73677
73678
73679
73680
73681
73682
73683
 
# File 'ext/ctp/ctp.cxx', line 73662

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

#OffsetFlag=(*args) ⇒ Object 



73633
73634
73635
73636
73637
73638
73639
73640
73641
73642
73643
73644
73645
73646
73647
73648
73649
73650
73651
73652
73653
73654
73655
73656
73657
73658
73659
 
# File 'ext/ctp/ctp.cxx', line 73633

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

#OrderSubmitStatus(*args) ⇒ Object 



74393
74394
74395
74396
74397
74398
74399
74400
74401
74402
74403
74404
74405
74406
74407
74408
74409
74410
74411
74412
74413
74414
 
# File 'ext/ctp/ctp.cxx', line 74393

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

#OrderSubmitStatus=(*args) ⇒ Object 



74364
74365
74366
74367
74368
74369
74370
74371
74372
74373
74374
74375
74376
74377
74378
74379
74380
74381
74382
74383
74384
74385
74386
74387
74388
74389
74390
 
# File 'ext/ctp/ctp.cxx', line 74364

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

#ParticipantID(*args) ⇒ Object 



74101
74102
74103
74104
74105
74106
74107
74108
74109
74110
74111
74112
74113
74114
74115
74116
74117
74118
74119
74120
74121
74122
74123
74124
74125
74126
74127
74128
 
# File 'ext/ctp/ctp.cxx', line 74101

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

#ParticipantID=(*args) ⇒ Object 



74071
74072
74073
74074
74075
74076
74077
74078
74079
74080
74081
74082
74083
74084
74085
74086
74087
74088
74089
74090
74091
74092
74093
74094
74095
74096
74097
74098
 
# File 'ext/ctp/ctp.cxx', line 74071

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

#PosiDirection(*args) ⇒ Object 



73821
73822
73823
73824
73825
73826
73827
73828
73829
73830
73831
73832
73833
73834
73835
73836
73837
73838
73839
73840
73841
73842
 
# File 'ext/ctp/ctp.cxx', line 73821

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

#PosiDirection=(*args) ⇒ Object 



73792
73793
73794
73795
73796
73797
73798
73799
73800
73801
73802
73803
73804
73805
73806
73807
73808
73809
73810
73811
73812
73813
73814
73815
73816
73817
73818
 
# File 'ext/ctp/ctp.cxx', line 73792

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

#RequestID(*args) ⇒ Object 



73549
73550
73551
73552
73553
73554
73555
73556
73557
73558
73559
73560
73561
73562
73563
73564
73565
73566
73567
73568
73569
73570
 
# File 'ext/ctp/ctp.cxx', line 73549

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

#RequestID=(*args) ⇒ Object 



73520
73521
73522
73523
73524
73525
73526
73527
73528
73529
73530
73531
73532
73533
73534
73535
73536
73537
73538
73539
73540
73541
73542
73543
73544
73545
73546
 
# File 'ext/ctp/ctp.cxx', line 73520

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

#ReservePositionFlag(*args) ⇒ Object 



73874
73875
73876
73877
73878
73879
73880
73881
73882
73883
73884
73885
73886
73887
73888
73889
73890
73891
73892
73893
73894
73895
 
# File 'ext/ctp/ctp.cxx', line 73874

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

#ReservePositionFlag=(*args) ⇒ Object 



73845
73846
73847
73848
73849
73850
73851
73852
73853
73854
73855
73856
73857
73858
73859
73860
73861
73862
73863
73864
73865
73866
73867
73868
73869
73870
73871
 
# File 'ext/ctp/ctp.cxx', line 73845

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

#SequenceNo(*args) ⇒ Object 



74965
74966
74967
74968
74969
74970
74971
74972
74973
74974
74975
74976
74977
74978
74979
74980
74981
74982
74983
74984
74985
74986
 
# File 'ext/ctp/ctp.cxx', line 74965

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

#SequenceNo=(*args) ⇒ Object 



74936
74937
74938
74939
74940
74941
74942
74943
74944
74945
74946
74947
74948
74949
74950
74951
74952
74953
74954
74955
74956
74957
74958
74959
74960
74961
74962
 
# File 'ext/ctp/ctp.cxx', line 74936

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

#SettlementID(*args) ⇒ Object 



74559
74560
74561
74562
74563
74564
74565
74566
74567
74568
74569
74570
74571
74572
74573
74574
74575
74576
74577
74578
74579
74580
 
# File 'ext/ctp/ctp.cxx', line 74559

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

#SettlementID=(*args) ⇒ Object 



74530
74531
74532
74533
74534
74535
74536
74537
74538
74539
74540
74541
74542
74543
74544
74545
74546
74547
74548
74549
74550
74551
74552
74553
74554
74555
74556
 
# File 'ext/ctp/ctp.cxx', line 74530

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

#TraderID(*args) ⇒ Object 



74281
74282
74283
74284
74285
74286
74287
74288
74289
74290
74291
74292
74293
74294
74295
74296
74297
74298
74299
74300
74301
74302
74303
74304
74305
74306
74307
74308
 
# File 'ext/ctp/ctp.cxx', line 74281

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

#TraderID=(*args) ⇒ Object 



74251
74252
74253
74254
74255
74256
74257
74258
74259
74260
74261
74262
74263
74264
74265
74266
74267
74268
74269
74270
74271
74272
74273
74274
74275
74276
74277
74278
 
# File 'ext/ctp/ctp.cxx', line 74251

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

#TradingDay(*args) ⇒ Object 



74500
74501
74502
74503
74504
74505
74506
74507
74508
74509
74510
74511
74512
74513
74514
74515
74516
74517
74518
74519
74520
74521
74522
74523
74524
74525
74526
74527
 
# File 'ext/ctp/ctp.cxx', line 74500

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



74470
74471
74472
74473
74474
74475
74476
74477
74478
74479
74480
74481
74482
74483
74484
74485
74486
74487
74488
74489
74490
74491
74492
74493
74494
74495
74496
74497
 
# File 'ext/ctp/ctp.cxx', line 74470

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

#Volume(*args) ⇒ Object 



73496
73497
73498
73499
73500
73501
73502
73503
73504
73505
73506
73507
73508
73509
73510
73511
73512
73513
73514
73515
73516
73517
 
# File 'ext/ctp/ctp.cxx', line 73496

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

#Volume=(*args) ⇒ Object 



73467
73468
73469
73470
73471
73472
73473
73474
73475
73476
73477
73478
73479
73480
73481
73482
73483
73484
73485
73486
73487
73488
73489
73490
73491
73492
73493
 
# File 'ext/ctp/ctp.cxx', line 73467

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