Class: Ctp::CThostFtdcErrOrderField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



120793
120794
120795
120796
120797
120798
120799
120800
120801
120802
120803
120804
120805
120806
 
# File 'ext/ctp/ctp.cxx', line 120793

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

Instance Method Details

#BrokerID(*args) ⇒ Object 



119413
119414
119415
119416
119417
119418
119419
119420
119421
119422
119423
119424
119425
119426
119427
119428
119429
119430
119431
119432
119433
119434
119435
119436
119437
119438
119439
119440
 
# File 'ext/ctp/ctp.cxx', line 119413

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



119383
119384
119385
119386
119387
119388
119389
119390
119391
119392
119393
119394
119395
119396
119397
119398
119399
119400
119401
119402
119403
119404
119405
119406
119407
119408
119409
119410
 
# File 'ext/ctp/ctp.cxx', line 119383

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



120476
120477
120478
120479
120480
120481
120482
120483
120484
120485
120486
120487
120488
120489
120490
120491
120492
120493
120494
120495
120496
120497
120498
120499
120500
120501
120502
120503
 
# File 'ext/ctp/ctp.cxx', line 120476

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



120446
120447
120448
120449
120450
120451
120452
120453
120454
120455
120456
120457
120458
120459
120460
120461
120462
120463
120464
120465
120466
120467
120468
120469
120470
120471
120472
120473
 
# File 'ext/ctp/ctp.cxx', line 120446

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



119879
119880
119881
119882
119883
119884
119885
119886
119887
119888
119889
119890
119891
119892
119893
119894
119895
119896
119897
119898
119899
119900
119901
119902
119903
119904
119905
119906
 
# File 'ext/ctp/ctp.cxx', line 119879

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



119849
119850
119851
119852
119853
119854
119855
119856
119857
119858
119859
119860
119861
119862
119863
119864
119865
119866
119867
119868
119869
119870
119871
119872
119873
119874
119875
119876
 
# File 'ext/ctp/ctp.cxx', line 119849

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



119819
119820
119821
119822
119823
119824
119825
119826
119827
119828
119829
119830
119831
119832
119833
119834
119835
119836
119837
119838
119839
119840
119841
119842
119843
119844
119845
119846
 
# File 'ext/ctp/ctp.cxx', line 119819

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



119789
119790
119791
119792
119793
119794
119795
119796
119797
119798
119799
119800
119801
119802
119803
119804
119805
119806
119807
119808
119809
119810
119811
119812
119813
119814
119815
119816
 
# File 'ext/ctp/ctp.cxx', line 119789

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



120263
120264
120265
120266
120267
120268
120269
120270
120271
120272
120273
120274
120275
120276
120277
120278
120279
120280
120281
120282
120283
120284
 
# File 'ext/ctp/ctp.cxx', line 120263

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

#ContingentCondition=(*args) ⇒ Object 



120234
120235
120236
120237
120238
120239
120240
120241
120242
120243
120244
120245
120246
120247
120248
120249
120250
120251
120252
120253
120254
120255
120256
120257
120258
120259
120260
 
# File 'ext/ctp/ctp.cxx', line 120234

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



119765
119766
119767
119768
119769
119770
119771
119772
119773
119774
119775
119776
119777
119778
119779
119780
119781
119782
119783
119784
119785
119786
 
# File 'ext/ctp/ctp.cxx', line 119765

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

#Direction=(*args) ⇒ Object 



119736
119737
119738
119739
119740
119741
119742
119743
119744
119745
119746
119747
119748
119749
119750
119751
119752
119753
119754
119755
119756
119757
119758
119759
119760
119761
119762
 
# File 'ext/ctp/ctp.cxx', line 119736

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

#ErrorID(*args) ⇒ Object 



120641
120642
120643
120644
120645
120646
120647
120648
120649
120650
120651
120652
120653
120654
120655
120656
120657
120658
120659
120660
120661
120662
 
# File 'ext/ctp/ctp.cxx', line 120641

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

#ErrorID=(*args) ⇒ Object 



120612
120613
120614
120615
120616
120617
120618
120619
120620
120621
120622
120623
120624
120625
120626
120627
120628
120629
120630
120631
120632
120633
120634
120635
120636
120637
120638
 
# File 'ext/ctp/ctp.cxx', line 120612

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

#ErrorMsg(*args) ⇒ Object 



120695
120696
120697
120698
120699
120700
120701
120702
120703
120704
120705
120706
120707
120708
120709
120710
120711
120712
120713
120714
120715
120716
120717
120718
120719
120720
120721
120722
 
# File 'ext/ctp/ctp.cxx', line 120695

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

#ErrorMsg=(*args) ⇒ Object 



120665
120666
120667
120668
120669
120670
120671
120672
120673
120674
120675
120676
120677
120678
120679
120680
120681
120682
120683
120684
120685
120686
120687
120688
120689
120690
120691
120692
 
# File 'ext/ctp/ctp.cxx', line 120665

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

#ForceCloseReason(*args) ⇒ Object 



120369
120370
120371
120372
120373
120374
120375
120376
120377
120378
120379
120380
120381
120382
120383
120384
120385
120386
120387
120388
120389
120390
 
# File 'ext/ctp/ctp.cxx', line 120369

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

#ForceCloseReason=(*args) ⇒ Object 



120340
120341
120342
120343
120344
120345
120346
120347
120348
120349
120350
120351
120352
120353
120354
120355
120356
120357
120358
120359
120360
120361
120362
120363
120364
120365
120366
 
# File 'ext/ctp/ctp.cxx', line 120340

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



120098
120099
120100
120101
120102
120103
120104
120105
120106
120107
120108
120109
120110
120111
120112
120113
120114
120115
120116
120117
120118
120119
120120
120121
120122
120123
120124
120125
 
# File 'ext/ctp/ctp.cxx', line 120098

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



120068
120069
120070
120071
120072
120073
120074
120075
120076
120077
120078
120079
120080
120081
120082
120083
120084
120085
120086
120087
120088
120089
120090
120091
120092
120093
120094
120095
 
# File 'ext/ctp/ctp.cxx', line 120068

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



119533
119534
119535
119536
119537
119538
119539
119540
119541
119542
119543
119544
119545
119546
119547
119548
119549
119550
119551
119552
119553
119554
119555
119556
119557
119558
119559
119560
 
# File 'ext/ctp/ctp.cxx', line 119533

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



119503
119504
119505
119506
119507
119508
119509
119510
119511
119512
119513
119514
119515
119516
119517
119518
119519
119520
119521
119522
119523
119524
119525
119526
119527
119528
119529
119530
 
# File 'ext/ctp/ctp.cxx', line 119503

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



119473
119474
119475
119476
119477
119478
119479
119480
119481
119482
119483
119484
119485
119486
119487
119488
119489
119490
119491
119492
119493
119494
119495
119496
119497
119498
119499
119500
 
# File 'ext/ctp/ctp.cxx', line 119473

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



119443
119444
119445
119446
119447
119448
119449
119450
119451
119452
119453
119454
119455
119456
119457
119458
119459
119460
119461
119462
119463
119464
119465
119466
119467
119468
119469
119470
 
# File 'ext/ctp/ctp.cxx', line 119443

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



120422
120423
120424
120425
120426
120427
120428
120429
120430
120431
120432
120433
120434
120435
120436
120437
120438
120439
120440
120441
120442
120443
 
# File 'ext/ctp/ctp.cxx', line 120422

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

#IsAutoSuspend=(*args) ⇒ Object 



120393
120394
120395
120396
120397
120398
120399
120400
120401
120402
120403
120404
120405
120406
120407
120408
120409
120410
120411
120412
120413
120414
120415
120416
120417
120418
120419
 
# File 'ext/ctp/ctp.cxx', line 120393

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



120754
120755
120756
120757
120758
120759
120760
120761
120762
120763
120764
120765
120766
120767
120768
120769
120770
120771
120772
120773
120774
120775
 
# File 'ext/ctp/ctp.cxx', line 120754

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

#IsSwapOrder=(*args) ⇒ Object 



120725
120726
120727
120728
120729
120730
120731
120732
120733
120734
120735
120736
120737
120738
120739
120740
120741
120742
120743
120744
120745
120746
120747
120748
120749
120750
120751
 
# File 'ext/ctp/ctp.cxx', line 120725

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



119938
119939
119940
119941
119942
119943
119944
119945
119946
119947
119948
119949
119950
119951
119952
119953
119954
119955
119956
119957
119958
119959
 
# File 'ext/ctp/ctp.cxx', line 119938

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

#LimitPrice=(*args) ⇒ Object 



119909
119910
119911
119912
119913
119914
119915
119916
119917
119918
119919
119920
119921
119922
119923
119924
119925
119926
119927
119928
119929
119930
119931
119932
119933
119934
119935
 
# File 'ext/ctp/ctp.cxx', line 119909

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



120210
120211
120212
120213
120214
120215
120216
120217
120218
120219
120220
120221
120222
120223
120224
120225
120226
120227
120228
120229
120230
120231
 
# File 'ext/ctp/ctp.cxx', line 120210

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

#MinVolume=(*args) ⇒ Object 



120181
120182
120183
120184
120185
120186
120187
120188
120189
120190
120191
120192
120193
120194
120195
120196
120197
120198
120199
120200
120201
120202
120203
120204
120205
120206
120207
 
# File 'ext/ctp/ctp.cxx', line 120181

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



119712
119713
119714
119715
119716
119717
119718
119719
119720
119721
119722
119723
119724
119725
119726
119727
119728
119729
119730
119731
119732
119733
 
# File 'ext/ctp/ctp.cxx', line 119712

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

#OrderPriceType=(*args) ⇒ Object 



119683
119684
119685
119686
119687
119688
119689
119690
119691
119692
119693
119694
119695
119696
119697
119698
119699
119700
119701
119702
119703
119704
119705
119706
119707
119708
119709
 
# File 'ext/ctp/ctp.cxx', line 119683

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



119593
119594
119595
119596
119597
119598
119599
119600
119601
119602
119603
119604
119605
119606
119607
119608
119609
119610
119611
119612
119613
119614
119615
119616
119617
119618
119619
119620
 
# File 'ext/ctp/ctp.cxx', line 119593

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



119563
119564
119565
119566
119567
119568
119569
119570
119571
119572
119573
119574
119575
119576
119577
119578
119579
119580
119581
119582
119583
119584
119585
119586
119587
119588
119589
119590
 
# File 'ext/ctp/ctp.cxx', line 119563

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



120535
120536
120537
120538
120539
120540
120541
120542
120543
120544
120545
120546
120547
120548
120549
120550
120551
120552
120553
120554
120555
120556
 
# File 'ext/ctp/ctp.cxx', line 120535

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

#RequestID=(*args) ⇒ Object 



120506
120507
120508
120509
120510
120511
120512
120513
120514
120515
120516
120517
120518
120519
120520
120521
120522
120523
120524
120525
120526
120527
120528
120529
120530
120531
120532
 
# File 'ext/ctp/ctp.cxx', line 120506

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



120316
120317
120318
120319
120320
120321
120322
120323
120324
120325
120326
120327
120328
120329
120330
120331
120332
120333
120334
120335
120336
120337
 
# File 'ext/ctp/ctp.cxx', line 120316

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

#StopPrice=(*args) ⇒ Object 



120287
120288
120289
120290
120291
120292
120293
120294
120295
120296
120297
120298
120299
120300
120301
120302
120303
120304
120305
120306
120307
120308
120309
120310
120311
120312
120313
 
# File 'ext/ctp/ctp.cxx', line 120287

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



120044
120045
120046
120047
120048
120049
120050
120051
120052
120053
120054
120055
120056
120057
120058
120059
120060
120061
120062
120063
120064
120065
 
# File 'ext/ctp/ctp.cxx', line 120044

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

#TimeCondition=(*args) ⇒ Object 



120015
120016
120017
120018
120019
120020
120021
120022
120023
120024
120025
120026
120027
120028
120029
120030
120031
120032
120033
120034
120035
120036
120037
120038
120039
120040
120041
 
# File 'ext/ctp/ctp.cxx', line 120015

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



120588
120589
120590
120591
120592
120593
120594
120595
120596
120597
120598
120599
120600
120601
120602
120603
120604
120605
120606
120607
120608
120609
 
# File 'ext/ctp/ctp.cxx', line 120588

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

#UserForceClose=(*args) ⇒ Object 



120559
120560
120561
120562
120563
120564
120565
120566
120567
120568
120569
120570
120571
120572
120573
120574
120575
120576
120577
120578
120579
120580
120581
120582
120583
120584
120585
 
# File 'ext/ctp/ctp.cxx', line 120559

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



119653
119654
119655
119656
119657
119658
119659
119660
119661
119662
119663
119664
119665
119666
119667
119668
119669
119670
119671
119672
119673
119674
119675
119676
119677
119678
119679
119680
 
# File 'ext/ctp/ctp.cxx', line 119653

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



119623
119624
119625
119626
119627
119628
119629
119630
119631
119632
119633
119634
119635
119636
119637
119638
119639
119640
119641
119642
119643
119644
119645
119646
119647
119648
119649
119650
 
# File 'ext/ctp/ctp.cxx', line 119623

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



120157
120158
120159
120160
120161
120162
120163
120164
120165
120166
120167
120168
120169
120170
120171
120172
120173
120174
120175
120176
120177
120178
 
# File 'ext/ctp/ctp.cxx', line 120157

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

#VolumeCondition=(*args) ⇒ Object 



120128
120129
120130
120131
120132
120133
120134
120135
120136
120137
120138
120139
120140
120141
120142
120143
120144
120145
120146
120147
120148
120149
120150
120151
120152
120153
120154
 
# File 'ext/ctp/ctp.cxx', line 120128

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



119991
119992
119993
119994
119995
119996
119997
119998
119999
120000
120001
120002
120003
120004
120005
120006
120007
120008
120009
120010
120011
120012
 
# File 'ext/ctp/ctp.cxx', line 119991

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

#VolumeTotalOriginal=(*args) ⇒ Object 



119962
119963
119964
119965
119966
119967
119968
119969
119970
119971
119972
119973
119974
119975
119976
119977
119978
119979
119980
119981
119982
119983
119984
119985
119986
119987
119988
 
# File 'ext/ctp/ctp.cxx', line 119962

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