Class: Ctp::CThostFtdcOrderActionField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



42646
42647
42648
42649
42650
42651
42652
42653
42654
42655
42656
42657
42658
42659
 
# File 'ext/ctp/ctp.cxx', line 42646

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

Instance Method Details

#ActionDate(*args) ⇒ Object 



41895
41896
41897
41898
41899
41900
41901
41902
41903
41904
41905
41906
41907
41908
41909
41910
41911
41912
41913
41914
41915
41916
41917
41918
41919
41920
41921
41922
 
# File 'ext/ctp/ctp.cxx', line 41895

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

#ActionDate=(*args) ⇒ Object 



41865
41866
41867
41868
41869
41870
41871
41872
41873
41874
41875
41876
41877
41878
41879
41880
41881
41882
41883
41884
41885
41886
41887
41888
41889
41890
41891
41892
 
# File 'ext/ctp/ctp.cxx', line 41865

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

#ActionFlag(*args) ⇒ Object 



41735
41736
41737
41738
41739
41740
41741
41742
41743
41744
41745
41746
41747
41748
41749
41750
41751
41752
41753
41754
41755
41756
 
# File 'ext/ctp/ctp.cxx', line 41735

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

#ActionFlag=(*args) ⇒ Object 



41706
41707
41708
41709
41710
41711
41712
41713
41714
41715
41716
41717
41718
41719
41720
41721
41722
41723
41724
41725
41726
41727
41728
41729
41730
41731
41732
 
# File 'ext/ctp/ctp.cxx', line 41706

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

#ActionLocalID(*args) ⇒ Object 



42188
42189
42190
42191
42192
42193
42194
42195
42196
42197
42198
42199
42200
42201
42202
42203
42204
42205
42206
42207
42208
42209
42210
42211
42212
42213
42214
42215
 
# File 'ext/ctp/ctp.cxx', line 42188

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

#ActionLocalID=(*args) ⇒ Object 



42158
42159
42160
42161
42162
42163
42164
42165
42166
42167
42168
42169
42170
42171
42172
42173
42174
42175
42176
42177
42178
42179
42180
42181
42182
42183
42184
42185
 
# File 'ext/ctp/ctp.cxx', line 42158

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

#ActionTime(*args) ⇒ Object 



41955
41956
41957
41958
41959
41960
41961
41962
41963
41964
41965
41966
41967
41968
41969
41970
41971
41972
41973
41974
41975
41976
41977
41978
41979
41980
41981
41982
 
# File 'ext/ctp/ctp.cxx', line 41955

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

#ActionTime=(*args) ⇒ Object 



41925
41926
41927
41928
41929
41930
41931
41932
41933
41934
41935
41936
41937
41938
41939
41940
41941
41942
41943
41944
41945
41946
41947
41948
41949
41950
41951
41952
 
# File 'ext/ctp/ctp.cxx', line 41925

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

#BrokerID(*args) ⇒ Object 



41224
41225
41226
41227
41228
41229
41230
41231
41232
41233
41234
41235
41236
41237
41238
41239
41240
41241
41242
41243
41244
41245
41246
41247
41248
41249
41250
41251
 
# File 'ext/ctp/ctp.cxx', line 41224

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



41194
41195
41196
41197
41198
41199
41200
41201
41202
41203
41204
41205
41206
41207
41208
41209
41210
41211
41212
41213
41214
41215
41216
41217
41218
41219
41220
41221
 
# File 'ext/ctp/ctp.cxx', line 41194

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



42368
42369
42370
42371
42372
42373
42374
42375
42376
42377
42378
42379
42380
42381
42382
42383
42384
42385
42386
42387
42388
42389
42390
42391
42392
42393
42394
42395
 
# File 'ext/ctp/ctp.cxx', line 42368

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



42338
42339
42340
42341
42342
42343
42344
42345
42346
42347
42348
42349
42350
42351
42352
42353
42354
42355
42356
42357
42358
42359
42360
42361
42362
42363
42364
42365
 
# File 'ext/ctp/ctp.cxx', line 42338

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

#ClientID(*args) ⇒ Object 



42308
42309
42310
42311
42312
42313
42314
42315
42316
42317
42318
42319
42320
42321
42322
42323
42324
42325
42326
42327
42328
42329
42330
42331
42332
42333
42334
42335
 
# File 'ext/ctp/ctp.cxx', line 42308

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

#ClientID=(*args) ⇒ Object 



42278
42279
42280
42281
42282
42283
42284
42285
42286
42287
42288
42289
42290
42291
42292
42293
42294
42295
42296
42297
42298
42299
42300
42301
42302
42303
42304
42305
 
# File 'ext/ctp/ctp.cxx', line 42278

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

#ExchangeID(*args) ⇒ Object 



41616
41617
41618
41619
41620
41621
41622
41623
41624
41625
41626
41627
41628
41629
41630
41631
41632
41633
41634
41635
41636
41637
41638
41639
41640
41641
41642
41643
 
# File 'ext/ctp/ctp.cxx', line 41616

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

#ExchangeID=(*args) ⇒ Object 



41586
41587
41588
41589
41590
41591
41592
41593
41594
41595
41596
41597
41598
41599
41600
41601
41602
41603
41604
41605
41606
41607
41608
41609
41610
41611
41612
41613
 
# File 'ext/ctp/ctp.cxx', line 41586

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

#FrontID(*args) ⇒ Object 



41509
41510
41511
41512
41513
41514
41515
41516
41517
41518
41519
41520
41521
41522
41523
41524
41525
41526
41527
41528
41529
41530
 
# File 'ext/ctp/ctp.cxx', line 41509

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

#FrontID=(*args) ⇒ Object 



41480
41481
41482
41483
41484
41485
41486
41487
41488
41489
41490
41491
41492
41493
41494
41495
41496
41497
41498
41499
41500
41501
41502
41503
41504
41505
41506
 
# File 'ext/ctp/ctp.cxx', line 41480

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

#InstallID(*args) ⇒ Object 



42074
42075
42076
42077
42078
42079
42080
42081
42082
42083
42084
42085
42086
42087
42088
42089
42090
42091
42092
42093
42094
42095
 
# File 'ext/ctp/ctp.cxx', line 42074

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

#InstallID=(*args) ⇒ Object 



42045
42046
42047
42048
42049
42050
42051
42052
42053
42054
42055
42056
42057
42058
42059
42060
42061
42062
42063
42064
42065
42066
42067
42068
42069
42070
42071
 
# File 'ext/ctp/ctp.cxx', line 42045

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

#InstrumentID(*args) ⇒ Object 



42601
42602
42603
42604
42605
42606
42607
42608
42609
42610
42611
42612
42613
42614
42615
42616
42617
42618
42619
42620
42621
42622
42623
42624
42625
42626
42627
42628
 
# File 'ext/ctp/ctp.cxx', line 42601

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



42571
42572
42573
42574
42575
42576
42577
42578
42579
42580
42581
42582
42583
42584
42585
42586
42587
42588
42589
42590
42591
42592
42593
42594
42595
42596
42597
42598
 
# File 'ext/ctp/ctp.cxx', line 42571

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



41284
41285
41286
41287
41288
41289
41290
41291
41292
41293
41294
41295
41296
41297
41298
41299
41300
41301
41302
41303
41304
41305
41306
41307
41308
41309
41310
41311
 
# File 'ext/ctp/ctp.cxx', line 41284

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



41254
41255
41256
41257
41258
41259
41260
41261
41262
41263
41264
41265
41266
41267
41268
41269
41270
41271
41272
41273
41274
41275
41276
41277
41278
41279
41280
41281
 
# File 'ext/ctp/ctp.cxx', line 41254

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

#LimitPrice(*args) ⇒ Object 



41788
41789
41790
41791
41792
41793
41794
41795
41796
41797
41798
41799
41800
41801
41802
41803
41804
41805
41806
41807
41808
41809
 
# File 'ext/ctp/ctp.cxx', line 41788

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

#LimitPrice=(*args) ⇒ Object 



41759
41760
41761
41762
41763
41764
41765
41766
41767
41768
41769
41770
41771
41772
41773
41774
41775
41776
41777
41778
41779
41780
41781
41782
41783
41784
41785
 
# File 'ext/ctp/ctp.cxx', line 41759

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

#OrderActionRef(*args) ⇒ Object 



41343
41344
41345
41346
41347
41348
41349
41350
41351
41352
41353
41354
41355
41356
41357
41358
41359
41360
41361
41362
41363
41364
 
# File 'ext/ctp/ctp.cxx', line 41343

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

#OrderActionRef=(*args) ⇒ Object 



41314
41315
41316
41317
41318
41319
41320
41321
41322
41323
41324
41325
41326
41327
41328
41329
41330
41331
41332
41333
41334
41335
41336
41337
41338
41339
41340
 
# File 'ext/ctp/ctp.cxx', line 41314

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

#OrderActionStatus(*args) ⇒ Object 



42427
42428
42429
42430
42431
42432
42433
42434
42435
42436
42437
42438
42439
42440
42441
42442
42443
42444
42445
42446
42447
42448
 
# File 'ext/ctp/ctp.cxx', line 42427

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

#OrderActionStatus=(*args) ⇒ Object 



42398
42399
42400
42401
42402
42403
42404
42405
42406
42407
42408
42409
42410
42411
42412
42413
42414
42415
42416
42417
42418
42419
42420
42421
42422
42423
42424
 
# File 'ext/ctp/ctp.cxx', line 42398

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

#OrderLocalID(*args) ⇒ Object 



42128
42129
42130
42131
42132
42133
42134
42135
42136
42137
42138
42139
42140
42141
42142
42143
42144
42145
42146
42147
42148
42149
42150
42151
42152
42153
42154
42155
 
# File 'ext/ctp/ctp.cxx', line 42128

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

#OrderLocalID=(*args) ⇒ Object 



42098
42099
42100
42101
42102
42103
42104
42105
42106
42107
42108
42109
42110
42111
42112
42113
42114
42115
42116
42117
42118
42119
42120
42121
42122
42123
42124
42125
 
# File 'ext/ctp/ctp.cxx', line 42098

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

#OrderRef(*args) ⇒ Object 



41397
41398
41399
41400
41401
41402
41403
41404
41405
41406
41407
41408
41409
41410
41411
41412
41413
41414
41415
41416
41417
41418
41419
41420
41421
41422
41423
41424
 
# File 'ext/ctp/ctp.cxx', line 41397

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



41367
41368
41369
41370
41371
41372
41373
41374
41375
41376
41377
41378
41379
41380
41381
41382
41383
41384
41385
41386
41387
41388
41389
41390
41391
41392
41393
41394
 
# File 'ext/ctp/ctp.cxx', line 41367

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

#OrderSysID(*args) ⇒ Object 



41676
41677
41678
41679
41680
41681
41682
41683
41684
41685
41686
41687
41688
41689
41690
41691
41692
41693
41694
41695
41696
41697
41698
41699
41700
41701
41702
41703
 
# File 'ext/ctp/ctp.cxx', line 41676

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

#OrderSysID=(*args) ⇒ Object 



41646
41647
41648
41649
41650
41651
41652
41653
41654
41655
41656
41657
41658
41659
41660
41661
41662
41663
41664
41665
41666
41667
41668
41669
41670
41671
41672
41673
 
# File 'ext/ctp/ctp.cxx', line 41646

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

#ParticipantID(*args) ⇒ Object 



42248
42249
42250
42251
42252
42253
42254
42255
42256
42257
42258
42259
42260
42261
42262
42263
42264
42265
42266
42267
42268
42269
42270
42271
42272
42273
42274
42275
 
# File 'ext/ctp/ctp.cxx', line 42248

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

#ParticipantID=(*args) ⇒ Object 



42218
42219
42220
42221
42222
42223
42224
42225
42226
42227
42228
42229
42230
42231
42232
42233
42234
42235
42236
42237
42238
42239
42240
42241
42242
42243
42244
42245
 
# File 'ext/ctp/ctp.cxx', line 42218

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

#RequestID(*args) ⇒ Object 



41456
41457
41458
41459
41460
41461
41462
41463
41464
41465
41466
41467
41468
41469
41470
41471
41472
41473
41474
41475
41476
41477
 
# File 'ext/ctp/ctp.cxx', line 41456

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

#RequestID=(*args) ⇒ Object 



41427
41428
41429
41430
41431
41432
41433
41434
41435
41436
41437
41438
41439
41440
41441
41442
41443
41444
41445
41446
41447
41448
41449
41450
41451
41452
41453
 
# File 'ext/ctp/ctp.cxx', line 41427

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

#SessionID(*args) ⇒ Object 



41562
41563
41564
41565
41566
41567
41568
41569
41570
41571
41572
41573
41574
41575
41576
41577
41578
41579
41580
41581
41582
41583
 
# File 'ext/ctp/ctp.cxx', line 41562

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

#SessionID=(*args) ⇒ Object 



41533
41534
41535
41536
41537
41538
41539
41540
41541
41542
41543
41544
41545
41546
41547
41548
41549
41550
41551
41552
41553
41554
41555
41556
41557
41558
41559
 
# File 'ext/ctp/ctp.cxx', line 41533

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

#StatusMsg(*args) ⇒ Object 



42541
42542
42543
42544
42545
42546
42547
42548
42549
42550
42551
42552
42553
42554
42555
42556
42557
42558
42559
42560
42561
42562
42563
42564
42565
42566
42567
42568
 
# File 'ext/ctp/ctp.cxx', line 42541

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

#StatusMsg=(*args) ⇒ Object 



42511
42512
42513
42514
42515
42516
42517
42518
42519
42520
42521
42522
42523
42524
42525
42526
42527
42528
42529
42530
42531
42532
42533
42534
42535
42536
42537
42538
 
# File 'ext/ctp/ctp.cxx', line 42511

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

#TraderID(*args) ⇒ Object 



42015
42016
42017
42018
42019
42020
42021
42022
42023
42024
42025
42026
42027
42028
42029
42030
42031
42032
42033
42034
42035
42036
42037
42038
42039
42040
42041
42042
 
# File 'ext/ctp/ctp.cxx', line 42015

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

#TraderID=(*args) ⇒ Object 



41985
41986
41987
41988
41989
41990
41991
41992
41993
41994
41995
41996
41997
41998
41999
42000
42001
42002
42003
42004
42005
42006
42007
42008
42009
42010
42011
42012
 
# File 'ext/ctp/ctp.cxx', line 41985

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

#UserID(*args) ⇒ Object 



42481
42482
42483
42484
42485
42486
42487
42488
42489
42490
42491
42492
42493
42494
42495
42496
42497
42498
42499
42500
42501
42502
42503
42504
42505
42506
42507
42508
 
# File 'ext/ctp/ctp.cxx', line 42481

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



42451
42452
42453
42454
42455
42456
42457
42458
42459
42460
42461
42462
42463
42464
42465
42466
42467
42468
42469
42470
42471
42472
42473
42474
42475
42476
42477
42478
 
# File 'ext/ctp/ctp.cxx', line 42451

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

#VolumeChange(*args) ⇒ Object 



41841
41842
41843
41844
41845
41846
41847
41848
41849
41850
41851
41852
41853
41854
41855
41856
41857
41858
41859
41860
41861
41862
 
# File 'ext/ctp/ctp.cxx', line 41841

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

#VolumeChange=(*args) ⇒ Object 



41812
41813
41814
41815
41816
41817
41818
41819
41820
41821
41822
41823
41824
41825
41826
41827
41828
41829
41830
41831
41832
41833
41834
41835
41836
41837
41838
 
# File 'ext/ctp/ctp.cxx', line 41812

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