Class: Ctp::CThostFtdcReqQueryTradeResultBySerialField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



164145
164146
164147
164148
164149
164150
164151
164152
164153
164154
164155
164156
164157
164158
 
# File 'ext/ctp/ctp.cxx', line 164145

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

Instance Method Details

#AccountID(*args) ⇒ Object 



163867
163868
163869
163870
163871
163872
163873
163874
163875
163876
163877
163878
163879
163880
163881
163882
163883
163884
163885
163886
163887
163888
163889
163890
163891
163892
163893
163894
 
# File 'ext/ctp/ctp.cxx', line 163867

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

#AccountID=(*args) ⇒ Object 



163837
163838
163839
163840
163841
163842
163843
163844
163845
163846
163847
163848
163849
163850
163851
163852
163853
163854
163855
163856
163857
163858
163859
163860
163861
163862
163863
163864
 
# File 'ext/ctp/ctp.cxx', line 163837

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

#BankAccount(*args) ⇒ Object 



163747
163748
163749
163750
163751
163752
163753
163754
163755
163756
163757
163758
163759
163760
163761
163762
163763
163764
163765
163766
163767
163768
163769
163770
163771
163772
163773
163774
 
# File 'ext/ctp/ctp.cxx', line 163747

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

#BankAccount=(*args) ⇒ Object 



163717
163718
163719
163720
163721
163722
163723
163724
163725
163726
163727
163728
163729
163730
163731
163732
163733
163734
163735
163736
163737
163738
163739
163740
163741
163742
163743
163744
 
# File 'ext/ctp/ctp.cxx', line 163717

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

#BankBranchID(*args) ⇒ Object 



162776
162777
162778
162779
162780
162781
162782
162783
162784
162785
162786
162787
162788
162789
162790
162791
162792
162793
162794
162795
162796
162797
162798
162799
162800
162801
162802
162803
 
# File 'ext/ctp/ctp.cxx', line 162776

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

#BankBranchID=(*args) ⇒ Object 



162746
162747
162748
162749
162750
162751
162752
162753
162754
162755
162756
162757
162758
162759
162760
162761
162762
162763
162764
162765
162766
162767
162768
162769
162770
162771
162772
162773
 
# File 'ext/ctp/ctp.cxx', line 162746

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

#BankID(*args) ⇒ Object 



162716
162717
162718
162719
162720
162721
162722
162723
162724
162725
162726
162727
162728
162729
162730
162731
162732
162733
162734
162735
162736
162737
162738
162739
162740
162741
162742
162743
 
# File 'ext/ctp/ctp.cxx', line 162716

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

#BankID=(*args) ⇒ Object 



162686
162687
162688
162689
162690
162691
162692
162693
162694
162695
162696
162697
162698
162699
162700
162701
162702
162703
162704
162705
162706
162707
162708
162709
162710
162711
162712
162713
 
# File 'ext/ctp/ctp.cxx', line 162686

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

#BankPassWord(*args) ⇒ Object 



163807
163808
163809
163810
163811
163812
163813
163814
163815
163816
163817
163818
163819
163820
163821
163822
163823
163824
163825
163826
163827
163828
163829
163830
163831
163832
163833
163834
 
# File 'ext/ctp/ctp.cxx', line 163807

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

#BankPassWord=(*args) ⇒ Object 



163777
163778
163779
163780
163781
163782
163783
163784
163785
163786
163787
163788
163789
163790
163791
163792
163793
163794
163795
163796
163797
163798
163799
163800
163801
163802
163803
163804
 
# File 'ext/ctp/ctp.cxx', line 163777

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

#BankSerial(*args) ⇒ Object 



163076
163077
163078
163079
163080
163081
163082
163083
163084
163085
163086
163087
163088
163089
163090
163091
163092
163093
163094
163095
163096
163097
163098
163099
163100
163101
163102
163103
 
# File 'ext/ctp/ctp.cxx', line 163076

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

#BankSerial=(*args) ⇒ Object 



163046
163047
163048
163049
163050
163051
163052
163053
163054
163055
163056
163057
163058
163059
163060
163061
163062
163063
163064
163065
163066
163067
163068
163069
163070
163071
163072
163073
 
# File 'ext/ctp/ctp.cxx', line 163046

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

#BrokerBranchID(*args) ⇒ Object 



162896
162897
162898
162899
162900
162901
162902
162903
162904
162905
162906
162907
162908
162909
162910
162911
162912
162913
162914
162915
162916
162917
162918
162919
162920
162921
162922
162923
 
# File 'ext/ctp/ctp.cxx', line 162896

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

#BrokerBranchID=(*args) ⇒ Object 



162866
162867
162868
162869
162870
162871
162872
162873
162874
162875
162876
162877
162878
162879
162880
162881
162882
162883
162884
162885
162886
162887
162888
162889
162890
162891
162892
162893
 
# File 'ext/ctp/ctp.cxx', line 162866

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

#BrokerID(*args) ⇒ Object 



162836
162837
162838
162839
162840
162841
162842
162843
162844
162845
162846
162847
162848
162849
162850
162851
162852
162853
162854
162855
162856
162857
162858
162859
162860
162861
162862
162863
 
# File 'ext/ctp/ctp.cxx', line 162836

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



162806
162807
162808
162809
162810
162811
162812
162813
162814
162815
162816
162817
162818
162819
162820
162821
162822
162823
162824
162825
162826
162827
162828
162829
162830
162831
162832
162833
 
# File 'ext/ctp/ctp.cxx', line 162806

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

#CurrencyID(*args) ⇒ Object 



163987
163988
163989
163990
163991
163992
163993
163994
163995
163996
163997
163998
163999
164000
164001
164002
164003
164004
164005
164006
164007
164008
164009
164010
164011
164012
164013
164014
 
# File 'ext/ctp/ctp.cxx', line 163987

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

#CurrencyID=(*args) ⇒ Object 



163957
163958
163959
163960
163961
163962
163963
163964
163965
163966
163967
163968
163969
163970
163971
163972
163973
163974
163975
163976
163977
163978
163979
163980
163981
163982
163983
163984
 
# File 'ext/ctp/ctp.cxx', line 163957

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

#CustomerName(*args) ⇒ Object 



163521
163522
163523
163524
163525
163526
163527
163528
163529
163530
163531
163532
163533
163534
163535
163536
163537
163538
163539
163540
163541
163542
163543
163544
163545
163546
163547
163548
 
# File 'ext/ctp/ctp.cxx', line 163521

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

#CustomerName=(*args) ⇒ Object 



163491
163492
163493
163494
163495
163496
163497
163498
163499
163500
163501
163502
163503
163504
163505
163506
163507
163508
163509
163510
163511
163512
163513
163514
163515
163516
163517
163518
 
# File 'ext/ctp/ctp.cxx', line 163491

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

#CustType(*args) ⇒ Object 



163693
163694
163695
163696
163697
163698
163699
163700
163701
163702
163703
163704
163705
163706
163707
163708
163709
163710
163711
163712
163713
163714
 
# File 'ext/ctp/ctp.cxx', line 163693

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

#CustType=(*args) ⇒ Object 



163664
163665
163666
163667
163668
163669
163670
163671
163672
163673
163674
163675
163676
163677
163678
163679
163680
163681
163682
163683
163684
163685
163686
163687
163688
163689
163690
 
# File 'ext/ctp/ctp.cxx', line 163664

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

#Digest(*args) ⇒ Object 



164100
164101
164102
164103
164104
164105
164106
164107
164108
164109
164110
164111
164112
164113
164114
164115
164116
164117
164118
164119
164120
164121
164122
164123
164124
164125
164126
164127
 
# File 'ext/ctp/ctp.cxx', line 164100

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

#Digest=(*args) ⇒ Object 



164070
164071
164072
164073
164074
164075
164076
164077
164078
164079
164080
164081
164082
164083
164084
164085
164086
164087
164088
164089
164090
164091
164092
164093
164094
164095
164096
164097
 
# File 'ext/ctp/ctp.cxx', line 164070

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

#IdCardType(*args) ⇒ Object 



163580
163581
163582
163583
163584
163585
163586
163587
163588
163589
163590
163591
163592
163593
163594
163595
163596
163597
163598
163599
163600
163601
 
# File 'ext/ctp/ctp.cxx', line 163580

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

#IdCardType=(*args) ⇒ Object 



163551
163552
163553
163554
163555
163556
163557
163558
163559
163560
163561
163562
163563
163564
163565
163566
163567
163568
163569
163570
163571
163572
163573
163574
163575
163576
163577
 
# File 'ext/ctp/ctp.cxx', line 163551

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

#IdentifiedCardNo(*args) ⇒ Object 



163634
163635
163636
163637
163638
163639
163640
163641
163642
163643
163644
163645
163646
163647
163648
163649
163650
163651
163652
163653
163654
163655
163656
163657
163658
163659
163660
163661
 
# File 'ext/ctp/ctp.cxx', line 163634

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

#IdentifiedCardNo=(*args) ⇒ Object 



163604
163605
163606
163607
163608
163609
163610
163611
163612
163613
163614
163615
163616
163617
163618
163619
163620
163621
163622
163623
163624
163625
163626
163627
163628
163629
163630
163631
 
# File 'ext/ctp/ctp.cxx', line 163604

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

#LastFragment(*args) ⇒ Object 



163248
163249
163250
163251
163252
163253
163254
163255
163256
163257
163258
163259
163260
163261
163262
163263
163264
163265
163266
163267
163268
163269
 
# File 'ext/ctp/ctp.cxx', line 163248

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

#LastFragment=(*args) ⇒ Object 



163219
163220
163221
163222
163223
163224
163225
163226
163227
163228
163229
163230
163231
163232
163233
163234
163235
163236
163237
163238
163239
163240
163241
163242
163243
163244
163245
 
# File 'ext/ctp/ctp.cxx', line 163219

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

#Password(*args) ⇒ Object 



163927
163928
163929
163930
163931
163932
163933
163934
163935
163936
163937
163938
163939
163940
163941
163942
163943
163944
163945
163946
163947
163948
163949
163950
163951
163952
163953
163954
 
# File 'ext/ctp/ctp.cxx', line 163927

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

#Password=(*args) ⇒ Object 



163897
163898
163899
163900
163901
163902
163903
163904
163905
163906
163907
163908
163909
163910
163911
163912
163913
163914
163915
163916
163917
163918
163919
163920
163921
163922
163923
163924
 
# File 'ext/ctp/ctp.cxx', line 163897

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

#PlateSerial(*args) ⇒ Object 



163195
163196
163197
163198
163199
163200
163201
163202
163203
163204
163205
163206
163207
163208
163209
163210
163211
163212
163213
163214
163215
163216
 
# File 'ext/ctp/ctp.cxx', line 163195

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

#PlateSerial=(*args) ⇒ Object 



163166
163167
163168
163169
163170
163171
163172
163173
163174
163175
163176
163177
163178
163179
163180
163181
163182
163183
163184
163185
163186
163187
163188
163189
163190
163191
163192
 
# File 'ext/ctp/ctp.cxx', line 163166

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

#Reference(*args) ⇒ Object 



163354
163355
163356
163357
163358
163359
163360
163361
163362
163363
163364
163365
163366
163367
163368
163369
163370
163371
163372
163373
163374
163375
 
# File 'ext/ctp/ctp.cxx', line 163354

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

#Reference=(*args) ⇒ Object 



163325
163326
163327
163328
163329
163330
163331
163332
163333
163334
163335
163336
163337
163338
163339
163340
163341
163342
163343
163344
163345
163346
163347
163348
163349
163350
163351
 
# File 'ext/ctp/ctp.cxx', line 163325

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

#RefrenceIssure(*args) ⇒ Object 



163461
163462
163463
163464
163465
163466
163467
163468
163469
163470
163471
163472
163473
163474
163475
163476
163477
163478
163479
163480
163481
163482
163483
163484
163485
163486
163487
163488
 
# File 'ext/ctp/ctp.cxx', line 163461

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

#RefrenceIssure=(*args) ⇒ Object 



163431
163432
163433
163434
163435
163436
163437
163438
163439
163440
163441
163442
163443
163444
163445
163446
163447
163448
163449
163450
163451
163452
163453
163454
163455
163456
163457
163458
 
# File 'ext/ctp/ctp.cxx', line 163431

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

#RefrenceIssureType(*args) ⇒ Object 



163407
163408
163409
163410
163411
163412
163413
163414
163415
163416
163417
163418
163419
163420
163421
163422
163423
163424
163425
163426
163427
163428
 
# File 'ext/ctp/ctp.cxx', line 163407

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

#RefrenceIssureType=(*args) ⇒ Object 



163378
163379
163380
163381
163382
163383
163384
163385
163386
163387
163388
163389
163390
163391
163392
163393
163394
163395
163396
163397
163398
163399
163400
163401
163402
163403
163404
 
# File 'ext/ctp/ctp.cxx', line 163378

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

#SessionID(*args) ⇒ Object 



163301
163302
163303
163304
163305
163306
163307
163308
163309
163310
163311
163312
163313
163314
163315
163316
163317
163318
163319
163320
163321
163322
 
# File 'ext/ctp/ctp.cxx', line 163301

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

#SessionID=(*args) ⇒ Object 



163272
163273
163274
163275
163276
163277
163278
163279
163280
163281
163282
163283
163284
163285
163286
163287
163288
163289
163290
163291
163292
163293
163294
163295
163296
163297
163298
 
# File 'ext/ctp/ctp.cxx', line 163272

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

#TradeAmount(*args) ⇒ Object 



164046
164047
164048
164049
164050
164051
164052
164053
164054
164055
164056
164057
164058
164059
164060
164061
164062
164063
164064
164065
164066
164067
 
# File 'ext/ctp/ctp.cxx', line 164046

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

#TradeAmount=(*args) ⇒ Object 



164017
164018
164019
164020
164021
164022
164023
164024
164025
164026
164027
164028
164029
164030
164031
164032
164033
164034
164035
164036
164037
164038
164039
164040
164041
164042
164043
 
# File 'ext/ctp/ctp.cxx', line 164017

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

#TradeCode(*args) ⇒ Object 



162656
162657
162658
162659
162660
162661
162662
162663
162664
162665
162666
162667
162668
162669
162670
162671
162672
162673
162674
162675
162676
162677
162678
162679
162680
162681
162682
162683
 
# File 'ext/ctp/ctp.cxx', line 162656

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

#TradeCode=(*args) ⇒ Object 



162626
162627
162628
162629
162630
162631
162632
162633
162634
162635
162636
162637
162638
162639
162640
162641
162642
162643
162644
162645
162646
162647
162648
162649
162650
162651
162652
162653
 
# File 'ext/ctp/ctp.cxx', line 162626

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

#TradeDate(*args) ⇒ Object 



162956
162957
162958
162959
162960
162961
162962
162963
162964
162965
162966
162967
162968
162969
162970
162971
162972
162973
162974
162975
162976
162977
162978
162979
162980
162981
162982
162983
 
# File 'ext/ctp/ctp.cxx', line 162956

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

#TradeDate=(*args) ⇒ Object 



162926
162927
162928
162929
162930
162931
162932
162933
162934
162935
162936
162937
162938
162939
162940
162941
162942
162943
162944
162945
162946
162947
162948
162949
162950
162951
162952
162953
 
# File 'ext/ctp/ctp.cxx', line 162926

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

#TradeTime(*args) ⇒ Object 



163016
163017
163018
163019
163020
163021
163022
163023
163024
163025
163026
163027
163028
163029
163030
163031
163032
163033
163034
163035
163036
163037
163038
163039
163040
163041
163042
163043
 
# File 'ext/ctp/ctp.cxx', line 163016

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

#TradeTime=(*args) ⇒ Object 



162986
162987
162988
162989
162990
162991
162992
162993
162994
162995
162996
162997
162998
162999
163000
163001
163002
163003
163004
163005
163006
163007
163008
163009
163010
163011
163012
163013
 
# File 'ext/ctp/ctp.cxx', line 162986

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

#TradingDay(*args) ⇒ Object 



163136
163137
163138
163139
163140
163141
163142
163143
163144
163145
163146
163147
163148
163149
163150
163151
163152
163153
163154
163155
163156
163157
163158
163159
163160
163161
163162
163163
 
# File 'ext/ctp/ctp.cxx', line 163136

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



163106
163107
163108
163109
163110
163111
163112
163113
163114
163115
163116
163117
163118
163119
163120
163121
163122
163123
163124
163125
163126
163127
163128
163129
163130
163131
163132
163133
 
# File 'ext/ctp/ctp.cxx', line 163106

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