Class: Ctp::CThostFtdcErrExecOrderField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



77688
77689
77690
77691
77692
77693
77694
77695
77696
77697
77698
77699
77700
77701
 
# File 'ext/ctp/ctp.cxx', line 77688

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

Instance Method Details

#ActionType(*args) ⇒ Object 



77377
77378
77379
77380
77381
77382
77383
77384
77385
77386
77387
77388
77389
77390
77391
77392
77393
77394
77395
77396
77397
77398
 
# File 'ext/ctp/ctp.cxx', line 77377

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

#ActionType=(*args) ⇒ Object 



77348
77349
77350
77351
77352
77353
77354
77355
77356
77357
77358
77359
77360
77361
77362
77363
77364
77365
77366
77367
77368
77369
77370
77371
77372
77373
77374
 
# File 'ext/ctp/ctp.cxx', line 77348

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

#BrokerID(*args) ⇒ Object 



76806
76807
76808
76809
76810
76811
76812
76813
76814
76815
76816
76817
76818
76819
76820
76821
76822
76823
76824
76825
76826
76827
76828
76829
76830
76831
76832
76833
 
# File 'ext/ctp/ctp.cxx', line 76806

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



76776
76777
76778
76779
76780
76781
76782
76783
76784
76785
76786
76787
76788
76789
76790
76791
76792
76793
76794
76795
76796
76797
76798
76799
76800
76801
76802
76803
 
# File 'ext/ctp/ctp.cxx', line 76776

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



77212
77213
77214
77215
77216
77217
77218
77219
77220
77221
77222
77223
77224
77225
77226
77227
77228
77229
77230
77231
77232
77233
77234
77235
77236
77237
77238
77239
 
# File 'ext/ctp/ctp.cxx', line 77212

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



77182
77183
77184
77185
77186
77187
77188
77189
77190
77191
77192
77193
77194
77195
77196
77197
77198
77199
77200
77201
77202
77203
77204
77205
77206
77207
77208
77209
 
# File 'ext/ctp/ctp.cxx', line 77182

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

#CloseFlag(*args) ⇒ Object 



77536
77537
77538
77539
77540
77541
77542
77543
77544
77545
77546
77547
77548
77549
77550
77551
77552
77553
77554
77555
77556
77557
 
# File 'ext/ctp/ctp.cxx', line 77536

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

#CloseFlag=(*args) ⇒ Object 



77507
77508
77509
77510
77511
77512
77513
77514
77515
77516
77517
77518
77519
77520
77521
77522
77523
77524
77525
77526
77527
77528
77529
77530
77531
77532
77533
 
# File 'ext/ctp/ctp.cxx', line 77507

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

#ErrorID(*args) ⇒ Object 



77589
77590
77591
77592
77593
77594
77595
77596
77597
77598
77599
77600
77601
77602
77603
77604
77605
77606
77607
77608
77609
77610
 
# File 'ext/ctp/ctp.cxx', line 77589

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

#ErrorID=(*args) ⇒ Object 



77560
77561
77562
77563
77564
77565
77566
77567
77568
77569
77570
77571
77572
77573
77574
77575
77576
77577
77578
77579
77580
77581
77582
77583
77584
77585
77586
 
# File 'ext/ctp/ctp.cxx', line 77560

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



77643
77644
77645
77646
77647
77648
77649
77650
77651
77652
77653
77654
77655
77656
77657
77658
77659
77660
77661
77662
77663
77664
77665
77666
77667
77668
77669
77670
 
# File 'ext/ctp/ctp.cxx', line 77643

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



77613
77614
77615
77616
77617
77618
77619
77620
77621
77622
77623
77624
77625
77626
77627
77628
77629
77630
77631
77632
77633
77634
77635
77636
77637
77638
77639
77640
 
# File 'ext/ctp/ctp.cxx', line 77613

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

#ExecOrderRef(*args) ⇒ Object 



76986
76987
76988
76989
76990
76991
76992
76993
76994
76995
76996
76997
76998
76999
77000
77001
77002
77003
77004
77005
77006
77007
77008
77009
77010
77011
77012
77013
 
# File 'ext/ctp/ctp.cxx', line 76986

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

#ExecOrderRef=(*args) ⇒ Object 



76956
76957
76958
76959
76960
76961
76962
76963
76964
76965
76966
76967
76968
76969
76970
76971
76972
76973
76974
76975
76976
76977
76978
76979
76980
76981
76982
76983
 
# File 'ext/ctp/ctp.cxx', line 76956

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

#HedgeFlag(*args) ⇒ Object 



77324
77325
77326
77327
77328
77329
77330
77331
77332
77333
77334
77335
77336
77337
77338
77339
77340
77341
77342
77343
77344
77345
 
# File 'ext/ctp/ctp.cxx', line 77324

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

#HedgeFlag=(*args) ⇒ Object 



77295
77296
77297
77298
77299
77300
77301
77302
77303
77304
77305
77306
77307
77308
77309
77310
77311
77312
77313
77314
77315
77316
77317
77318
77319
77320
77321
 
# File 'ext/ctp/ctp.cxx', line 77295

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

#InstrumentID(*args) ⇒ Object 



76926
76927
76928
76929
76930
76931
76932
76933
76934
76935
76936
76937
76938
76939
76940
76941
76942
76943
76944
76945
76946
76947
76948
76949
76950
76951
76952
76953
 
# File 'ext/ctp/ctp.cxx', line 76926

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



76896
76897
76898
76899
76900
76901
76902
76903
76904
76905
76906
76907
76908
76909
76910
76911
76912
76913
76914
76915
76916
76917
76918
76919
76920
76921
76922
76923
 
# File 'ext/ctp/ctp.cxx', line 76896

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



76866
76867
76868
76869
76870
76871
76872
76873
76874
76875
76876
76877
76878
76879
76880
76881
76882
76883
76884
76885
76886
76887
76888
76889
76890
76891
76892
76893
 
# File 'ext/ctp/ctp.cxx', line 76866

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



76836
76837
76838
76839
76840
76841
76842
76843
76844
76845
76846
76847
76848
76849
76850
76851
76852
76853
76854
76855
76856
76857
76858
76859
76860
76861
76862
76863
 
# File 'ext/ctp/ctp.cxx', line 76836

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

#OffsetFlag(*args) ⇒ Object 



77271
77272
77273
77274
77275
77276
77277
77278
77279
77280
77281
77282
77283
77284
77285
77286
77287
77288
77289
77290
77291
77292
 
# File 'ext/ctp/ctp.cxx', line 77271

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

#OffsetFlag=(*args) ⇒ Object 



77242
77243
77244
77245
77246
77247
77248
77249
77250
77251
77252
77253
77254
77255
77256
77257
77258
77259
77260
77261
77262
77263
77264
77265
77266
77267
77268
 
# File 'ext/ctp/ctp.cxx', line 77242

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

#PosiDirection(*args) ⇒ Object 



77430
77431
77432
77433
77434
77435
77436
77437
77438
77439
77440
77441
77442
77443
77444
77445
77446
77447
77448
77449
77450
77451
 
# File 'ext/ctp/ctp.cxx', line 77430

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

#PosiDirection=(*args) ⇒ Object 



77401
77402
77403
77404
77405
77406
77407
77408
77409
77410
77411
77412
77413
77414
77415
77416
77417
77418
77419
77420
77421
77422
77423
77424
77425
77426
77427
 
# File 'ext/ctp/ctp.cxx', line 77401

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

#RequestID(*args) ⇒ Object 



77158
77159
77160
77161
77162
77163
77164
77165
77166
77167
77168
77169
77170
77171
77172
77173
77174
77175
77176
77177
77178
77179
 
# File 'ext/ctp/ctp.cxx', line 77158

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

#RequestID=(*args) ⇒ Object 



77129
77130
77131
77132
77133
77134
77135
77136
77137
77138
77139
77140
77141
77142
77143
77144
77145
77146
77147
77148
77149
77150
77151
77152
77153
77154
77155
 
# File 'ext/ctp/ctp.cxx', line 77129

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

#ReservePositionFlag(*args) ⇒ Object 



77483
77484
77485
77486
77487
77488
77489
77490
77491
77492
77493
77494
77495
77496
77497
77498
77499
77500
77501
77502
77503
77504
 
# File 'ext/ctp/ctp.cxx', line 77483

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

#ReservePositionFlag=(*args) ⇒ Object 



77454
77455
77456
77457
77458
77459
77460
77461
77462
77463
77464
77465
77466
77467
77468
77469
77470
77471
77472
77473
77474
77475
77476
77477
77478
77479
77480
 
# File 'ext/ctp/ctp.cxx', line 77454

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

#UserID(*args) ⇒ Object 



77046
77047
77048
77049
77050
77051
77052
77053
77054
77055
77056
77057
77058
77059
77060
77061
77062
77063
77064
77065
77066
77067
77068
77069
77070
77071
77072
77073
 
# File 'ext/ctp/ctp.cxx', line 77046

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



77016
77017
77018
77019
77020
77021
77022
77023
77024
77025
77026
77027
77028
77029
77030
77031
77032
77033
77034
77035
77036
77037
77038
77039
77040
77041
77042
77043
 
# File 'ext/ctp/ctp.cxx', line 77016

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

#Volume(*args) ⇒ Object 



77105
77106
77107
77108
77109
77110
77111
77112
77113
77114
77115
77116
77117
77118
77119
77120
77121
77122
77123
77124
77125
77126
 
# File 'ext/ctp/ctp.cxx', line 77105

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

#Volume=(*args) ⇒ Object 



77076
77077
77078
77079
77080
77081
77082
77083
77084
77085
77086
77087
77088
77089
77090
77091
77092
77093
77094
77095
77096
77097
77098
77099
77100
77101
77102
 
# File 'ext/ctp/ctp.cxx', line 77076

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