Class: Ctp::CThostFtdcTransferQryDetailRspField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



11114
11115
11116
11117
11118
11119
11120
11121
11122
11123
11124
11125
11126
11127
 
# File 'ext/ctp/ctp.cxx', line 11114

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

Instance Method Details

#BankAccount(*args) ⇒ Object 



10843
10844
10845
10846
10847
10848
10849
10850
10851
10852
10853
10854
10855
10856
10857
10858
10859
10860
10861
10862
10863
10864
10865
10866
10867
10868
10869
10870
 
# File 'ext/ctp/ctp.cxx', line 10843

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



10813
10814
10815
10816
10817
10818
10819
10820
10821
10822
10823
10824
10825
10826
10827
10828
10829
10830
10831
10832
10833
10834
10835
10836
10837
10838
10839
10840
 
# File 'ext/ctp/ctp.cxx', line 10813

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

#BankBrchID(*args) ⇒ Object 



10783
10784
10785
10786
10787
10788
10789
10790
10791
10792
10793
10794
10795
10796
10797
10798
10799
10800
10801
10802
10803
10804
10805
10806
10807
10808
10809
10810
 
# File 'ext/ctp/ctp.cxx', line 10783

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

#BankBrchID=(*args) ⇒ Object 



10753
10754
10755
10756
10757
10758
10759
10760
10761
10762
10763
10764
10765
10766
10767
10768
10769
10770
10771
10772
10773
10774
10775
10776
10777
10778
10779
10780
 
# File 'ext/ctp/ctp.cxx', line 10753

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

#BankID(*args) ⇒ Object 



10723
10724
10725
10726
10727
10728
10729
10730
10731
10732
10733
10734
10735
10736
10737
10738
10739
10740
10741
10742
10743
10744
10745
10746
10747
10748
10749
10750
 
# File 'ext/ctp/ctp.cxx', line 10723

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



10693
10694
10695
10696
10697
10698
10699
10700
10701
10702
10703
10704
10705
10706
10707
10708
10709
10710
10711
10712
10713
10714
10715
10716
10717
10718
10719
10720
 
# File 'ext/ctp/ctp.cxx', line 10693

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

#BankSerial(*args) ⇒ Object 



10669
10670
10671
10672
10673
10674
10675
10676
10677
10678
10679
10680
10681
10682
10683
10684
10685
10686
10687
10688
10689
10690
 
# File 'ext/ctp/ctp.cxx', line 10669

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

#BankSerial=(*args) ⇒ Object 



10640
10641
10642
10643
10644
10645
10646
10647
10648
10649
10650
10651
10652
10653
10654
10655
10656
10657
10658
10659
10660
10661
10662
10663
10664
10665
10666
 
# File 'ext/ctp/ctp.cxx', line 10640

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

#CertCode(*args) ⇒ Object 



10903
10904
10905
10906
10907
10908
10909
10910
10911
10912
10913
10914
10915
10916
10917
10918
10919
10920
10921
10922
10923
10924
10925
10926
10927
10928
10929
10930
 
# File 'ext/ctp/ctp.cxx', line 10903

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

#CertCode=(*args) ⇒ Object 



10873
10874
10875
10876
10877
10878
10879
10880
10881
10882
10883
10884
10885
10886
10887
10888
10889
10890
10891
10892
10893
10894
10895
10896
10897
10898
10899
10900
 
# File 'ext/ctp/ctp.cxx', line 10873

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

#CurrencyCode(*args) ⇒ Object 



10963
10964
10965
10966
10967
10968
10969
10970
10971
10972
10973
10974
10975
10976
10977
10978
10979
10980
10981
10982
10983
10984
10985
10986
10987
10988
10989
10990
 
# File 'ext/ctp/ctp.cxx', line 10963

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

#CurrencyCode=(*args) ⇒ Object 



10933
10934
10935
10936
10937
10938
10939
10940
10941
10942
10943
10944
10945
10946
10947
10948
10949
10950
10951
10952
10953
10954
10955
10956
10957
10958
10959
10960
 
# File 'ext/ctp/ctp.cxx', line 10933

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

#Flag(*args) ⇒ Object 



11075
11076
11077
11078
11079
11080
11081
11082
11083
11084
11085
11086
11087
11088
11089
11090
11091
11092
11093
11094
11095
11096
 
# File 'ext/ctp/ctp.cxx', line 11075

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

#Flag=(*args) ⇒ Object 



11046
11047
11048
11049
11050
11051
11052
11053
11054
11055
11056
11057
11058
11059
11060
11061
11062
11063
11064
11065
11066
11067
11068
11069
11070
11071
11072
 
# File 'ext/ctp/ctp.cxx', line 11046

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

#FutureAccount(*args) ⇒ Object 



10610
10611
10612
10613
10614
10615
10616
10617
10618
10619
10620
10621
10622
10623
10624
10625
10626
10627
10628
10629
10630
10631
10632
10633
10634
10635
10636
10637
 
# File 'ext/ctp/ctp.cxx', line 10610

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

#FutureAccount=(*args) ⇒ Object 



10580
10581
10582
10583
10584
10585
10586
10587
10588
10589
10590
10591
10592
10593
10594
10595
10596
10597
10598
10599
10600
10601
10602
10603
10604
10605
10606
10607
 
# File 'ext/ctp/ctp.cxx', line 10580

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

#FutureID(*args) ⇒ Object 



10550
10551
10552
10553
10554
10555
10556
10557
10558
10559
10560
10561
10562
10563
10564
10565
10566
10567
10568
10569
10570
10571
10572
10573
10574
10575
10576
10577
 
# File 'ext/ctp/ctp.cxx', line 10550

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

#FutureID=(*args) ⇒ Object 



10520
10521
10522
10523
10524
10525
10526
10527
10528
10529
10530
10531
10532
10533
10534
10535
10536
10537
10538
10539
10540
10541
10542
10543
10544
10545
10546
10547
 
# File 'ext/ctp/ctp.cxx', line 10520

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

#FutureSerial(*args) ⇒ Object 



10496
10497
10498
10499
10500
10501
10502
10503
10504
10505
10506
10507
10508
10509
10510
10511
10512
10513
10514
10515
10516
10517
 
# File 'ext/ctp/ctp.cxx', line 10496

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

#FutureSerial=(*args) ⇒ Object 



10467
10468
10469
10470
10471
10472
10473
10474
10475
10476
10477
10478
10479
10480
10481
10482
10483
10484
10485
10486
10487
10488
10489
10490
10491
10492
10493
 
# File 'ext/ctp/ctp.cxx', line 10467

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

#TradeCode(*args) ⇒ Object 



10437
10438
10439
10440
10441
10442
10443
10444
10445
10446
10447
10448
10449
10450
10451
10452
10453
10454
10455
10456
10457
10458
10459
10460
10461
10462
10463
10464
 
# File 'ext/ctp/ctp.cxx', line 10437

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



10407
10408
10409
10410
10411
10412
10413
10414
10415
10416
10417
10418
10419
10420
10421
10422
10423
10424
10425
10426
10427
10428
10429
10430
10431
10432
10433
10434
 
# File 'ext/ctp/ctp.cxx', line 10407

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



10317
10318
10319
10320
10321
10322
10323
10324
10325
10326
10327
10328
10329
10330
10331
10332
10333
10334
10335
10336
10337
10338
10339
10340
10341
10342
10343
10344
 
# File 'ext/ctp/ctp.cxx', line 10317

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



10287
10288
10289
10290
10291
10292
10293
10294
10295
10296
10297
10298
10299
10300
10301
10302
10303
10304
10305
10306
10307
10308
10309
10310
10311
10312
10313
10314
 
# File 'ext/ctp/ctp.cxx', line 10287

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



10377
10378
10379
10380
10381
10382
10383
10384
10385
10386
10387
10388
10389
10390
10391
10392
10393
10394
10395
10396
10397
10398
10399
10400
10401
10402
10403
10404
 
# File 'ext/ctp/ctp.cxx', line 10377

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



10347
10348
10349
10350
10351
10352
10353
10354
10355
10356
10357
10358
10359
10360
10361
10362
10363
10364
10365
10366
10367
10368
10369
10370
10371
10372
10373
10374
 
# File 'ext/ctp/ctp.cxx', line 10347

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

#TxAmount(*args) ⇒ Object 



11022
11023
11024
11025
11026
11027
11028
11029
11030
11031
11032
11033
11034
11035
11036
11037
11038
11039
11040
11041
11042
11043
 
# File 'ext/ctp/ctp.cxx', line 11022

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

#TxAmount=(*args) ⇒ Object 



10993
10994
10995
10996
10997
10998
10999
11000
11001
11002
11003
11004
11005
11006
11007
11008
11009
11010
11011
11012
11013
11014
11015
11016
11017
11018
11019
 
# File 'ext/ctp/ctp.cxx', line 10993

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