Class: Ctp::CThostFtdcInputOrderField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



34227
34228
34229
34230
34231
34232
34233
34234
34235
34236
34237
34238
34239
34240
 
# File 'ext/ctp/ctp.cxx', line 34227

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

Instance Method Details

#BrokerID(*args) ⇒ Object 



32960
32961
32962
32963
32964
32965
32966
32967
32968
32969
32970
32971
32972
32973
32974
32975
32976
32977
32978
32979
32980
32981
32982
32983
32984
32985
32986
32987
 
# File 'ext/ctp/ctp.cxx', line 32960

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



32930
32931
32932
32933
32934
32935
32936
32937
32938
32939
32940
32941
32942
32943
32944
32945
32946
32947
32948
32949
32950
32951
32952
32953
32954
32955
32956
32957
 
# File 'ext/ctp/ctp.cxx', line 32930

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

#BusinessUnit(*args) ⇒ Object 



34023
34024
34025
34026
34027
34028
34029
34030
34031
34032
34033
34034
34035
34036
34037
34038
34039
34040
34041
34042
34043
34044
34045
34046
34047
34048
34049
34050
 
# File 'ext/ctp/ctp.cxx', line 34023

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

#BusinessUnit=(*args) ⇒ Object 



33993
33994
33995
33996
33997
33998
33999
34000
34001
34002
34003
34004
34005
34006
34007
34008
34009
34010
34011
34012
34013
34014
34015
34016
34017
34018
34019
34020
 
# File 'ext/ctp/ctp.cxx', line 33993

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

#CombHedgeFlag(*args) ⇒ Object 



33426
33427
33428
33429
33430
33431
33432
33433
33434
33435
33436
33437
33438
33439
33440
33441
33442
33443
33444
33445
33446
33447
33448
33449
33450
33451
33452
33453
 
# File 'ext/ctp/ctp.cxx', line 33426

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

#CombHedgeFlag=(*args) ⇒ Object 



33396
33397
33398
33399
33400
33401
33402
33403
33404
33405
33406
33407
33408
33409
33410
33411
33412
33413
33414
33415
33416
33417
33418
33419
33420
33421
33422
33423
 
# File 'ext/ctp/ctp.cxx', line 33396

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

#CombOffsetFlag(*args) ⇒ Object 



33366
33367
33368
33369
33370
33371
33372
33373
33374
33375
33376
33377
33378
33379
33380
33381
33382
33383
33384
33385
33386
33387
33388
33389
33390
33391
33392
33393
 
# File 'ext/ctp/ctp.cxx', line 33366

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

#CombOffsetFlag=(*args) ⇒ Object 



33336
33337
33338
33339
33340
33341
33342
33343
33344
33345
33346
33347
33348
33349
33350
33351
33352
33353
33354
33355
33356
33357
33358
33359
33360
33361
33362
33363
 
# File 'ext/ctp/ctp.cxx', line 33336

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

#ContingentCondition(*args) ⇒ Object 



33810
33811
33812
33813
33814
33815
33816
33817
33818
33819
33820
33821
33822
33823
33824
33825
33826
33827
33828
33829
33830
33831
 
# File 'ext/ctp/ctp.cxx', line 33810

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

#ContingentCondition=(*args) ⇒ Object 



33781
33782
33783
33784
33785
33786
33787
33788
33789
33790
33791
33792
33793
33794
33795
33796
33797
33798
33799
33800
33801
33802
33803
33804
33805
33806
33807
 
# File 'ext/ctp/ctp.cxx', line 33781

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

#Direction(*args) ⇒ Object 



33312
33313
33314
33315
33316
33317
33318
33319
33320
33321
33322
33323
33324
33325
33326
33327
33328
33329
33330
33331
33332
33333
 
# File 'ext/ctp/ctp.cxx', line 33312

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

#Direction=(*args) ⇒ Object 



33283
33284
33285
33286
33287
33288
33289
33290
33291
33292
33293
33294
33295
33296
33297
33298
33299
33300
33301
33302
33303
33304
33305
33306
33307
33308
33309
 
# File 'ext/ctp/ctp.cxx', line 33283

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

#ForceCloseReason(*args) ⇒ Object 



33916
33917
33918
33919
33920
33921
33922
33923
33924
33925
33926
33927
33928
33929
33930
33931
33932
33933
33934
33935
33936
33937
 
# File 'ext/ctp/ctp.cxx', line 33916

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

#ForceCloseReason=(*args) ⇒ Object 



33887
33888
33889
33890
33891
33892
33893
33894
33895
33896
33897
33898
33899
33900
33901
33902
33903
33904
33905
33906
33907
33908
33909
33910
33911
33912
33913
 
# File 'ext/ctp/ctp.cxx', line 33887

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

#GTDDate(*args) ⇒ Object 



33645
33646
33647
33648
33649
33650
33651
33652
33653
33654
33655
33656
33657
33658
33659
33660
33661
33662
33663
33664
33665
33666
33667
33668
33669
33670
33671
33672
 
# File 'ext/ctp/ctp.cxx', line 33645

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

#GTDDate=(*args) ⇒ Object 



33615
33616
33617
33618
33619
33620
33621
33622
33623
33624
33625
33626
33627
33628
33629
33630
33631
33632
33633
33634
33635
33636
33637
33638
33639
33640
33641
33642
 
# File 'ext/ctp/ctp.cxx', line 33615

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

#InstrumentID(*args) ⇒ Object 



33080
33081
33082
33083
33084
33085
33086
33087
33088
33089
33090
33091
33092
33093
33094
33095
33096
33097
33098
33099
33100
33101
33102
33103
33104
33105
33106
33107
 
# File 'ext/ctp/ctp.cxx', line 33080

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

#InstrumentID=(*args) ⇒ Object 



33050
33051
33052
33053
33054
33055
33056
33057
33058
33059
33060
33061
33062
33063
33064
33065
33066
33067
33068
33069
33070
33071
33072
33073
33074
33075
33076
33077
 
# File 'ext/ctp/ctp.cxx', line 33050

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

#InvestorID(*args) ⇒ Object 



33020
33021
33022
33023
33024
33025
33026
33027
33028
33029
33030
33031
33032
33033
33034
33035
33036
33037
33038
33039
33040
33041
33042
33043
33044
33045
33046
33047
 
# File 'ext/ctp/ctp.cxx', line 33020

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

#InvestorID=(*args) ⇒ Object 



32990
32991
32992
32993
32994
32995
32996
32997
32998
32999
33000
33001
33002
33003
33004
33005
33006
33007
33008
33009
33010
33011
33012
33013
33014
33015
33016
33017
 
# File 'ext/ctp/ctp.cxx', line 32990

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

#IsAutoSuspend(*args) ⇒ Object 



33969
33970
33971
33972
33973
33974
33975
33976
33977
33978
33979
33980
33981
33982
33983
33984
33985
33986
33987
33988
33989
33990
 
# File 'ext/ctp/ctp.cxx', line 33969

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

#IsAutoSuspend=(*args) ⇒ Object 



33940
33941
33942
33943
33944
33945
33946
33947
33948
33949
33950
33951
33952
33953
33954
33955
33956
33957
33958
33959
33960
33961
33962
33963
33964
33965
33966
 
# File 'ext/ctp/ctp.cxx', line 33940

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

#IsSwapOrder(*args) ⇒ Object 



34188
34189
34190
34191
34192
34193
34194
34195
34196
34197
34198
34199
34200
34201
34202
34203
34204
34205
34206
34207
34208
34209
 
# File 'ext/ctp/ctp.cxx', line 34188

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

#IsSwapOrder=(*args) ⇒ Object 



34159
34160
34161
34162
34163
34164
34165
34166
34167
34168
34169
34170
34171
34172
34173
34174
34175
34176
34177
34178
34179
34180
34181
34182
34183
34184
34185
 
# File 'ext/ctp/ctp.cxx', line 34159

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

#LimitPrice(*args) ⇒ Object 



33485
33486
33487
33488
33489
33490
33491
33492
33493
33494
33495
33496
33497
33498
33499
33500
33501
33502
33503
33504
33505
33506
 
# File 'ext/ctp/ctp.cxx', line 33485

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

#LimitPrice=(*args) ⇒ Object 



33456
33457
33458
33459
33460
33461
33462
33463
33464
33465
33466
33467
33468
33469
33470
33471
33472
33473
33474
33475
33476
33477
33478
33479
33480
33481
33482
 
# File 'ext/ctp/ctp.cxx', line 33456

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

#MinVolume(*args) ⇒ Object 



33757
33758
33759
33760
33761
33762
33763
33764
33765
33766
33767
33768
33769
33770
33771
33772
33773
33774
33775
33776
33777
33778
 
# File 'ext/ctp/ctp.cxx', line 33757

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

#MinVolume=(*args) ⇒ Object 



33728
33729
33730
33731
33732
33733
33734
33735
33736
33737
33738
33739
33740
33741
33742
33743
33744
33745
33746
33747
33748
33749
33750
33751
33752
33753
33754
 
# File 'ext/ctp/ctp.cxx', line 33728

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

#OrderPriceType(*args) ⇒ Object 



33259
33260
33261
33262
33263
33264
33265
33266
33267
33268
33269
33270
33271
33272
33273
33274
33275
33276
33277
33278
33279
33280
 
# File 'ext/ctp/ctp.cxx', line 33259

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

#OrderPriceType=(*args) ⇒ Object 



33230
33231
33232
33233
33234
33235
33236
33237
33238
33239
33240
33241
33242
33243
33244
33245
33246
33247
33248
33249
33250
33251
33252
33253
33254
33255
33256
 
# File 'ext/ctp/ctp.cxx', line 33230

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

#OrderRef(*args) ⇒ Object 



33140
33141
33142
33143
33144
33145
33146
33147
33148
33149
33150
33151
33152
33153
33154
33155
33156
33157
33158
33159
33160
33161
33162
33163
33164
33165
33166
33167
 
# File 'ext/ctp/ctp.cxx', line 33140

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

#OrderRef=(*args) ⇒ Object 



33110
33111
33112
33113
33114
33115
33116
33117
33118
33119
33120
33121
33122
33123
33124
33125
33126
33127
33128
33129
33130
33131
33132
33133
33134
33135
33136
33137
 
# File 'ext/ctp/ctp.cxx', line 33110

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

#RequestID(*args) ⇒ Object 



34082
34083
34084
34085
34086
34087
34088
34089
34090
34091
34092
34093
34094
34095
34096
34097
34098
34099
34100
34101
34102
34103
 
# File 'ext/ctp/ctp.cxx', line 34082

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

#RequestID=(*args) ⇒ Object 



34053
34054
34055
34056
34057
34058
34059
34060
34061
34062
34063
34064
34065
34066
34067
34068
34069
34070
34071
34072
34073
34074
34075
34076
34077
34078
34079
 
# File 'ext/ctp/ctp.cxx', line 34053

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

#StopPrice(*args) ⇒ Object 



33863
33864
33865
33866
33867
33868
33869
33870
33871
33872
33873
33874
33875
33876
33877
33878
33879
33880
33881
33882
33883
33884
 
# File 'ext/ctp/ctp.cxx', line 33863

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

#StopPrice=(*args) ⇒ Object 



33834
33835
33836
33837
33838
33839
33840
33841
33842
33843
33844
33845
33846
33847
33848
33849
33850
33851
33852
33853
33854
33855
33856
33857
33858
33859
33860
 
# File 'ext/ctp/ctp.cxx', line 33834

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

#TimeCondition(*args) ⇒ Object 



33591
33592
33593
33594
33595
33596
33597
33598
33599
33600
33601
33602
33603
33604
33605
33606
33607
33608
33609
33610
33611
33612
 
# File 'ext/ctp/ctp.cxx', line 33591

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

#TimeCondition=(*args) ⇒ Object 



33562
33563
33564
33565
33566
33567
33568
33569
33570
33571
33572
33573
33574
33575
33576
33577
33578
33579
33580
33581
33582
33583
33584
33585
33586
33587
33588
 
# File 'ext/ctp/ctp.cxx', line 33562

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

#UserForceClose(*args) ⇒ Object 



34135
34136
34137
34138
34139
34140
34141
34142
34143
34144
34145
34146
34147
34148
34149
34150
34151
34152
34153
34154
34155
34156
 
# File 'ext/ctp/ctp.cxx', line 34135

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

#UserForceClose=(*args) ⇒ Object 



34106
34107
34108
34109
34110
34111
34112
34113
34114
34115
34116
34117
34118
34119
34120
34121
34122
34123
34124
34125
34126
34127
34128
34129
34130
34131
34132
 
# File 'ext/ctp/ctp.cxx', line 34106

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

#UserID(*args) ⇒ Object 



33200
33201
33202
33203
33204
33205
33206
33207
33208
33209
33210
33211
33212
33213
33214
33215
33216
33217
33218
33219
33220
33221
33222
33223
33224
33225
33226
33227
 
# File 'ext/ctp/ctp.cxx', line 33200

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

#UserID=(*args) ⇒ Object 



33170
33171
33172
33173
33174
33175
33176
33177
33178
33179
33180
33181
33182
33183
33184
33185
33186
33187
33188
33189
33190
33191
33192
33193
33194
33195
33196
33197
 
# File 'ext/ctp/ctp.cxx', line 33170

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

#VolumeCondition(*args) ⇒ Object 



33704
33705
33706
33707
33708
33709
33710
33711
33712
33713
33714
33715
33716
33717
33718
33719
33720
33721
33722
33723
33724
33725
 
# File 'ext/ctp/ctp.cxx', line 33704

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

#VolumeCondition=(*args) ⇒ Object 



33675
33676
33677
33678
33679
33680
33681
33682
33683
33684
33685
33686
33687
33688
33689
33690
33691
33692
33693
33694
33695
33696
33697
33698
33699
33700
33701
 
# File 'ext/ctp/ctp.cxx', line 33675

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

#VolumeTotalOriginal(*args) ⇒ Object 



33538
33539
33540
33541
33542
33543
33544
33545
33546
33547
33548
33549
33550
33551
33552
33553
33554
33555
33556
33557
33558
33559
 
# File 'ext/ctp/ctp.cxx', line 33538

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

#VolumeTotalOriginal=(*args) ⇒ Object 



33509
33510
33511
33512
33513
33514
33515
33516
33517
33518
33519
33520
33521
33522
33523
33524
33525
33526
33527
33528
33529
33530
33531
33532
33533
33534
33535
 
# File 'ext/ctp/ctp.cxx', line 33509

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