Class: Ctp::CThostFtdcProductField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



12453
12454
12455
12456
12457
12458
12459
12460
12461
12462
12463
12464
12465
12466
 
# File 'ext/ctp/ctp.cxx', line 12453

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

Instance Method Details

#CloseDealType(*args) ⇒ Object 



12188
12189
12190
12191
12192
12193
12194
12195
12196
12197
12198
12199
12200
12201
12202
12203
12204
12205
12206
12207
12208
12209
 
# File 'ext/ctp/ctp.cxx', line 12188

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

#CloseDealType=(*args) ⇒ Object 



12159
12160
12161
12162
12163
12164
12165
12166
12167
12168
12169
12170
12171
12172
12173
12174
12175
12176
12177
12178
12179
12180
12181
12182
12183
12184
12185
 
# File 'ext/ctp/ctp.cxx', line 12159

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

#ExchangeID(*args) ⇒ Object 



11652
11653
11654
11655
11656
11657
11658
11659
11660
11661
11662
11663
11664
11665
11666
11667
11668
11669
11670
11671
11672
11673
11674
11675
11676
11677
11678
11679
 
# File 'ext/ctp/ctp.cxx', line 11652

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

#ExchangeID=(*args) ⇒ Object 



11622
11623
11624
11625
11626
11627
11628
11629
11630
11631
11632
11633
11634
11635
11636
11637
11638
11639
11640
11641
11642
11643
11644
11645
11646
11647
11648
11649
 
# File 'ext/ctp/ctp.cxx', line 11622

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

#ExchangeProductID(*args) ⇒ Object 



12355
12356
12357
12358
12359
12360
12361
12362
12363
12364
12365
12366
12367
12368
12369
12370
12371
12372
12373
12374
12375
12376
12377
12378
12379
12380
12381
12382
 
# File 'ext/ctp/ctp.cxx', line 12355

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

#ExchangeProductID=(*args) ⇒ Object 



12325
12326
12327
12328
12329
12330
12331
12332
12333
12334
12335
12336
12337
12338
12339
12340
12341
12342
12343
12344
12345
12346
12347
12348
12349
12350
12351
12352
 
# File 'ext/ctp/ctp.cxx', line 12325

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

#MaxLimitOrderVolume(*args) ⇒ Object 



11976
11977
11978
11979
11980
11981
11982
11983
11984
11985
11986
11987
11988
11989
11990
11991
11992
11993
11994
11995
11996
11997
 
# File 'ext/ctp/ctp.cxx', line 11976

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

#MaxLimitOrderVolume=(*args) ⇒ Object 



11947
11948
11949
11950
11951
11952
11953
11954
11955
11956
11957
11958
11959
11960
11961
11962
11963
11964
11965
11966
11967
11968
11969
11970
11971
11972
11973
 
# File 'ext/ctp/ctp.cxx', line 11947

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

#MaxMarketOrderVolume(*args) ⇒ Object 



11870
11871
11872
11873
11874
11875
11876
11877
11878
11879
11880
11881
11882
11883
11884
11885
11886
11887
11888
11889
11890
11891
 
# File 'ext/ctp/ctp.cxx', line 11870

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

#MaxMarketOrderVolume=(*args) ⇒ Object 



11841
11842
11843
11844
11845
11846
11847
11848
11849
11850
11851
11852
11853
11854
11855
11856
11857
11858
11859
11860
11861
11862
11863
11864
11865
11866
11867
 
# File 'ext/ctp/ctp.cxx', line 11841

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

#MinLimitOrderVolume(*args) ⇒ Object 



12029
12030
12031
12032
12033
12034
12035
12036
12037
12038
12039
12040
12041
12042
12043
12044
12045
12046
12047
12048
12049
12050
 
# File 'ext/ctp/ctp.cxx', line 12029

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

#MinLimitOrderVolume=(*args) ⇒ Object 



12000
12001
12002
12003
12004
12005
12006
12007
12008
12009
12010
12011
12012
12013
12014
12015
12016
12017
12018
12019
12020
12021
12022
12023
12024
12025
12026
 
# File 'ext/ctp/ctp.cxx', line 12000

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

#MinMarketOrderVolume(*args) ⇒ Object 



11923
11924
11925
11926
11927
11928
11929
11930
11931
11932
11933
11934
11935
11936
11937
11938
11939
11940
11941
11942
11943
11944
 
# File 'ext/ctp/ctp.cxx', line 11923

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

#MinMarketOrderVolume=(*args) ⇒ Object 



11894
11895
11896
11897
11898
11899
11900
11901
11902
11903
11904
11905
11906
11907
11908
11909
11910
11911
11912
11913
11914
11915
11916
11917
11918
11919
11920
 
# File 'ext/ctp/ctp.cxx', line 11894

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

#MortgageFundUseRange(*args) ⇒ Object 



12301
12302
12303
12304
12305
12306
12307
12308
12309
12310
12311
12312
12313
12314
12315
12316
12317
12318
12319
12320
12321
12322
 
# File 'ext/ctp/ctp.cxx', line 12301

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

#MortgageFundUseRange=(*args) ⇒ Object 



12272
12273
12274
12275
12276
12277
12278
12279
12280
12281
12282
12283
12284
12285
12286
12287
12288
12289
12290
12291
12292
12293
12294
12295
12296
12297
12298
 
# File 'ext/ctp/ctp.cxx', line 12272

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

#PositionDateType(*args) ⇒ Object 



12135
12136
12137
12138
12139
12140
12141
12142
12143
12144
12145
12146
12147
12148
12149
12150
12151
12152
12153
12154
12155
12156
 
# File 'ext/ctp/ctp.cxx', line 12135

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

#PositionDateType=(*args) ⇒ Object 



12106
12107
12108
12109
12110
12111
12112
12113
12114
12115
12116
12117
12118
12119
12120
12121
12122
12123
12124
12125
12126
12127
12128
12129
12130
12131
12132
 
# File 'ext/ctp/ctp.cxx', line 12106

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

#PositionType(*args) ⇒ Object 



12082
12083
12084
12085
12086
12087
12088
12089
12090
12091
12092
12093
12094
12095
12096
12097
12098
12099
12100
12101
12102
12103
 
# File 'ext/ctp/ctp.cxx', line 12082

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

#PositionType=(*args) ⇒ Object 



12053
12054
12055
12056
12057
12058
12059
12060
12061
12062
12063
12064
12065
12066
12067
12068
12069
12070
12071
12072
12073
12074
12075
12076
12077
12078
12079
 
# File 'ext/ctp/ctp.cxx', line 12053

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

#PriceTick(*args) ⇒ Object 



11817
11818
11819
11820
11821
11822
11823
11824
11825
11826
11827
11828
11829
11830
11831
11832
11833
11834
11835
11836
11837
11838
 
# File 'ext/ctp/ctp.cxx', line 11817

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

#PriceTick=(*args) ⇒ Object 



11788
11789
11790
11791
11792
11793
11794
11795
11796
11797
11798
11799
11800
11801
11802
11803
11804
11805
11806
11807
11808
11809
11810
11811
11812
11813
11814
 
# File 'ext/ctp/ctp.cxx', line 11788

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

#ProductClass(*args) ⇒ Object 



11711
11712
11713
11714
11715
11716
11717
11718
11719
11720
11721
11722
11723
11724
11725
11726
11727
11728
11729
11730
11731
11732
 
# File 'ext/ctp/ctp.cxx', line 11711

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

#ProductClass=(*args) ⇒ Object 



11682
11683
11684
11685
11686
11687
11688
11689
11690
11691
11692
11693
11694
11695
11696
11697
11698
11699
11700
11701
11702
11703
11704
11705
11706
11707
11708
 
# File 'ext/ctp/ctp.cxx', line 11682

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

#ProductID(*args) ⇒ Object 



11532
11533
11534
11535
11536
11537
11538
11539
11540
11541
11542
11543
11544
11545
11546
11547
11548
11549
11550
11551
11552
11553
11554
11555
11556
11557
11558
11559
 
# File 'ext/ctp/ctp.cxx', line 11532

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

#ProductID=(*args) ⇒ Object 



11502
11503
11504
11505
11506
11507
11508
11509
11510
11511
11512
11513
11514
11515
11516
11517
11518
11519
11520
11521
11522
11523
11524
11525
11526
11527
11528
11529
 
# File 'ext/ctp/ctp.cxx', line 11502

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

#ProductName(*args) ⇒ Object 



11592
11593
11594
11595
11596
11597
11598
11599
11600
11601
11602
11603
11604
11605
11606
11607
11608
11609
11610
11611
11612
11613
11614
11615
11616
11617
11618
11619
 
# File 'ext/ctp/ctp.cxx', line 11592

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

#ProductName=(*args) ⇒ Object 



11562
11563
11564
11565
11566
11567
11568
11569
11570
11571
11572
11573
11574
11575
11576
11577
11578
11579
11580
11581
11582
11583
11584
11585
11586
11587
11588
11589
 
# File 'ext/ctp/ctp.cxx', line 11562

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

#TradeCurrencyID(*args) ⇒ Object 



12242
12243
12244
12245
12246
12247
12248
12249
12250
12251
12252
12253
12254
12255
12256
12257
12258
12259
12260
12261
12262
12263
12264
12265
12266
12267
12268
12269
 
# File 'ext/ctp/ctp.cxx', line 12242

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

#TradeCurrencyID=(*args) ⇒ Object 



12212
12213
12214
12215
12216
12217
12218
12219
12220
12221
12222
12223
12224
12225
12226
12227
12228
12229
12230
12231
12232
12233
12234
12235
12236
12237
12238
12239
 
# File 'ext/ctp/ctp.cxx', line 12212

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

#UnderlyingMultiple(*args) ⇒ Object 



12414
12415
12416
12417
12418
12419
12420
12421
12422
12423
12424
12425
12426
12427
12428
12429
12430
12431
12432
12433
12434
12435
 
# File 'ext/ctp/ctp.cxx', line 12414

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

#UnderlyingMultiple=(*args) ⇒ Object 



12385
12386
12387
12388
12389
12390
12391
12392
12393
12394
12395
12396
12397
12398
12399
12400
12401
12402
12403
12404
12405
12406
12407
12408
12409
12410
12411
 
# File 'ext/ctp/ctp.cxx', line 12385

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

#VolumeMultiple(*args) ⇒ Object 



11764
11765
11766
11767
11768
11769
11770
11771
11772
11773
11774
11775
11776
11777
11778
11779
11780
11781
11782
11783
11784
11785
 
# File 'ext/ctp/ctp.cxx', line 11764

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

#VolumeMultiple=(*args) ⇒ Object 



11735
11736
11737
11738
11739
11740
11741
11742
11743
11744
11745
11746
11747
11748
11749
11750
11751
11752
11753
11754
11755
11756
11757
11758
11759
11760
11761
 
# File 'ext/ctp/ctp.cxx', line 11735

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