Class: Ctp::CThostFtdcParkedOrderField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



114806
114807
114808
114809
114810
114811
114812
114813
114814
114815
114816
114817
114818
114819
 
# File 'ext/ctp/ctp.cxx', line 114806

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

Instance Method Details

#BrokerID(*args) ⇒ Object 



113200
113201
113202
113203
113204
113205
113206
113207
113208
113209
113210
113211
113212
113213
113214
113215
113216
113217
113218
113219
113220
113221
113222
113223
113224
113225
113226
113227
 
# File 'ext/ctp/ctp.cxx', line 113200

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



113170
113171
113172
113173
113174
113175
113176
113177
113178
113179
113180
113181
113182
113183
113184
113185
113186
113187
113188
113189
113190
113191
113192
113193
113194
113195
113196
113197
 
# File 'ext/ctp/ctp.cxx', line 113170

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



114263
114264
114265
114266
114267
114268
114269
114270
114271
114272
114273
114274
114275
114276
114277
114278
114279
114280
114281
114282
114283
114284
114285
114286
114287
114288
114289
114290
 
# File 'ext/ctp/ctp.cxx', line 114263

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



114233
114234
114235
114236
114237
114238
114239
114240
114241
114242
114243
114244
114245
114246
114247
114248
114249
114250
114251
114252
114253
114254
114255
114256
114257
114258
114259
114260
 
# File 'ext/ctp/ctp.cxx', line 114233

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

#CombHedgeFlag(*args) ⇒ Object 



113666
113667
113668
113669
113670
113671
113672
113673
113674
113675
113676
113677
113678
113679
113680
113681
113682
113683
113684
113685
113686
113687
113688
113689
113690
113691
113692
113693
 
# File 'ext/ctp/ctp.cxx', line 113666

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

#CombHedgeFlag=(*args) ⇒ Object 



113636
113637
113638
113639
113640
113641
113642
113643
113644
113645
113646
113647
113648
113649
113650
113651
113652
113653
113654
113655
113656
113657
113658
113659
113660
113661
113662
113663
 
# File 'ext/ctp/ctp.cxx', line 113636

SWIGINTERN VALUE
_wrap_CThostFtdcParkedOrderField_CombHedgeFlag_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcParkedOrderField *arg1 = (CThostFtdcParkedOrderField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[5] ;
  int res2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcParkedOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcParkedOrderField *","CombHedgeFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcParkedOrderField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 5);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [5]","CombHedgeFlag", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->CombHedgeFlag,arg2,5*sizeof(char));
  else memset(arg1->CombHedgeFlag,0,5*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#CombOffsetFlag(*args) ⇒ Object 



113606
113607
113608
113609
113610
113611
113612
113613
113614
113615
113616
113617
113618
113619
113620
113621
113622
113623
113624
113625
113626
113627
113628
113629
113630
113631
113632
113633
 
# File 'ext/ctp/ctp.cxx', line 113606

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

#CombOffsetFlag=(*args) ⇒ Object 



113576
113577
113578
113579
113580
113581
113582
113583
113584
113585
113586
113587
113588
113589
113590
113591
113592
113593
113594
113595
113596
113597
113598
113599
113600
113601
113602
113603
 
# File 'ext/ctp/ctp.cxx', line 113576

SWIGINTERN VALUE
_wrap_CThostFtdcParkedOrderField_CombOffsetFlag_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcParkedOrderField *arg1 = (CThostFtdcParkedOrderField *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[5] ;
  int res2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcParkedOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcParkedOrderField *","CombOffsetFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcParkedOrderField * >(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 5);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [5]","CombOffsetFlag", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->CombOffsetFlag,arg2,5*sizeof(char));
  else memset(arg1->CombOffsetFlag,0,5*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#ContingentCondition(*args) ⇒ Object 



114050
114051
114052
114053
114054
114055
114056
114057
114058
114059
114060
114061
114062
114063
114064
114065
114066
114067
114068
114069
114070
114071
 
# File 'ext/ctp/ctp.cxx', line 114050

SWIGINTERN VALUE
_wrap_CThostFtdcParkedOrderField_ContingentCondition_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcParkedOrderField *arg1 = (CThostFtdcParkedOrderField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcContingentConditionType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcParkedOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcParkedOrderField *","ContingentCondition", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcParkedOrderField * >(argp1);
  result = (TThostFtdcContingentConditionType) ((arg1)->ContingentCondition);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#ContingentCondition=(*args) ⇒ Object 



114021
114022
114023
114024
114025
114026
114027
114028
114029
114030
114031
114032
114033
114034
114035
114036
114037
114038
114039
114040
114041
114042
114043
114044
114045
114046
114047
 
# File 'ext/ctp/ctp.cxx', line 114021

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

#Direction(*args) ⇒ Object 



113552
113553
113554
113555
113556
113557
113558
113559
113560
113561
113562
113563
113564
113565
113566
113567
113568
113569
113570
113571
113572
113573
 
# File 'ext/ctp/ctp.cxx', line 113552

SWIGINTERN VALUE
_wrap_CThostFtdcParkedOrderField_Direction_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcParkedOrderField *arg1 = (CThostFtdcParkedOrderField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcDirectionType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcParkedOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcParkedOrderField *","Direction", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcParkedOrderField * >(argp1);
  result = (TThostFtdcDirectionType) ((arg1)->Direction);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#Direction=(*args) ⇒ Object 



113523
113524
113525
113526
113527
113528
113529
113530
113531
113532
113533
113534
113535
113536
113537
113538
113539
113540
113541
113542
113543
113544
113545
113546
113547
113548
113549
 
# File 'ext/ctp/ctp.cxx', line 113523

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

#ErrorID(*args) ⇒ Object 



114654
114655
114656
114657
114658
114659
114660
114661
114662
114663
114664
114665
114666
114667
114668
114669
114670
114671
114672
114673
114674
114675
 
# File 'ext/ctp/ctp.cxx', line 114654

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

#ErrorID=(*args) ⇒ Object 



114625
114626
114627
114628
114629
114630
114631
114632
114633
114634
114635
114636
114637
114638
114639
114640
114641
114642
114643
114644
114645
114646
114647
114648
114649
114650
114651
 
# File 'ext/ctp/ctp.cxx', line 114625

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



114708
114709
114710
114711
114712
114713
114714
114715
114716
114717
114718
114719
114720
114721
114722
114723
114724
114725
114726
114727
114728
114729
114730
114731
114732
114733
114734
114735
 
# File 'ext/ctp/ctp.cxx', line 114708

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



114678
114679
114680
114681
114682
114683
114684
114685
114686
114687
114688
114689
114690
114691
114692
114693
114694
114695
114696
114697
114698
114699
114700
114701
114702
114703
114704
114705
 
# File 'ext/ctp/ctp.cxx', line 114678

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

#ExchangeID(*args) ⇒ Object 



114429
114430
114431
114432
114433
114434
114435
114436
114437
114438
114439
114440
114441
114442
114443
114444
114445
114446
114447
114448
114449
114450
114451
114452
114453
114454
114455
114456
 
# File 'ext/ctp/ctp.cxx', line 114429

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



114399
114400
114401
114402
114403
114404
114405
114406
114407
114408
114409
114410
114411
114412
114413
114414
114415
114416
114417
114418
114419
114420
114421
114422
114423
114424
114425
114426
 
# File 'ext/ctp/ctp.cxx', line 114399

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

#ForceCloseReason(*args) ⇒ Object 



114156
114157
114158
114159
114160
114161
114162
114163
114164
114165
114166
114167
114168
114169
114170
114171
114172
114173
114174
114175
114176
114177
 
# File 'ext/ctp/ctp.cxx', line 114156

SWIGINTERN VALUE
_wrap_CThostFtdcParkedOrderField_ForceCloseReason_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcParkedOrderField *arg1 = (CThostFtdcParkedOrderField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcForceCloseReasonType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcParkedOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcParkedOrderField *","ForceCloseReason", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcParkedOrderField * >(argp1);
  result = (TThostFtdcForceCloseReasonType) ((arg1)->ForceCloseReason);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#ForceCloseReason=(*args) ⇒ Object 



114127
114128
114129
114130
114131
114132
114133
114134
114135
114136
114137
114138
114139
114140
114141
114142
114143
114144
114145
114146
114147
114148
114149
114150
114151
114152
114153
 
# File 'ext/ctp/ctp.cxx', line 114127

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

#GTDDate(*args) ⇒ Object 



113885
113886
113887
113888
113889
113890
113891
113892
113893
113894
113895
113896
113897
113898
113899
113900
113901
113902
113903
113904
113905
113906
113907
113908
113909
113910
113911
113912
 
# File 'ext/ctp/ctp.cxx', line 113885

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

#GTDDate=(*args) ⇒ Object 



113855
113856
113857
113858
113859
113860
113861
113862
113863
113864
113865
113866
113867
113868
113869
113870
113871
113872
113873
113874
113875
113876
113877
113878
113879
113880
113881
113882
 
# File 'ext/ctp/ctp.cxx', line 113855

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

#InstrumentID(*args) ⇒ Object 



113320
113321
113322
113323
113324
113325
113326
113327
113328
113329
113330
113331
113332
113333
113334
113335
113336
113337
113338
113339
113340
113341
113342
113343
113344
113345
113346
113347
 
# File 'ext/ctp/ctp.cxx', line 113320

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



113290
113291
113292
113293
113294
113295
113296
113297
113298
113299
113300
113301
113302
113303
113304
113305
113306
113307
113308
113309
113310
113311
113312
113313
113314
113315
113316
113317
 
# File 'ext/ctp/ctp.cxx', line 113290

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



113260
113261
113262
113263
113264
113265
113266
113267
113268
113269
113270
113271
113272
113273
113274
113275
113276
113277
113278
113279
113280
113281
113282
113283
113284
113285
113286
113287
 
# File 'ext/ctp/ctp.cxx', line 113260

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



113230
113231
113232
113233
113234
113235
113236
113237
113238
113239
113240
113241
113242
113243
113244
113245
113246
113247
113248
113249
113250
113251
113252
113253
113254
113255
113256
113257
 
# File 'ext/ctp/ctp.cxx', line 113230

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

#IsAutoSuspend(*args) ⇒ Object 



114209
114210
114211
114212
114213
114214
114215
114216
114217
114218
114219
114220
114221
114222
114223
114224
114225
114226
114227
114228
114229
114230
 
# File 'ext/ctp/ctp.cxx', line 114209

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

#IsAutoSuspend=(*args) ⇒ Object 



114180
114181
114182
114183
114184
114185
114186
114187
114188
114189
114190
114191
114192
114193
114194
114195
114196
114197
114198
114199
114200
114201
114202
114203
114204
114205
114206
 
# File 'ext/ctp/ctp.cxx', line 114180

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

#IsSwapOrder(*args) ⇒ Object 



114767
114768
114769
114770
114771
114772
114773
114774
114775
114776
114777
114778
114779
114780
114781
114782
114783
114784
114785
114786
114787
114788
 
# File 'ext/ctp/ctp.cxx', line 114767

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

#IsSwapOrder=(*args) ⇒ Object 



114738
114739
114740
114741
114742
114743
114744
114745
114746
114747
114748
114749
114750
114751
114752
114753
114754
114755
114756
114757
114758
114759
114760
114761
114762
114763
114764
 
# File 'ext/ctp/ctp.cxx', line 114738

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

#LimitPrice(*args) ⇒ Object 



113725
113726
113727
113728
113729
113730
113731
113732
113733
113734
113735
113736
113737
113738
113739
113740
113741
113742
113743
113744
113745
113746
 
# File 'ext/ctp/ctp.cxx', line 113725

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

#LimitPrice=(*args) ⇒ Object 



113696
113697
113698
113699
113700
113701
113702
113703
113704
113705
113706
113707
113708
113709
113710
113711
113712
113713
113714
113715
113716
113717
113718
113719
113720
113721
113722
 
# File 'ext/ctp/ctp.cxx', line 113696

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

#MinVolume(*args) ⇒ Object 



113997
113998
113999
114000
114001
114002
114003
114004
114005
114006
114007
114008
114009
114010
114011
114012
114013
114014
114015
114016
114017
114018
 
# File 'ext/ctp/ctp.cxx', line 113997

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

#MinVolume=(*args) ⇒ Object 



113968
113969
113970
113971
113972
113973
113974
113975
113976
113977
113978
113979
113980
113981
113982
113983
113984
113985
113986
113987
113988
113989
113990
113991
113992
113993
113994
 
# File 'ext/ctp/ctp.cxx', line 113968

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

#OrderPriceType(*args) ⇒ Object 



113499
113500
113501
113502
113503
113504
113505
113506
113507
113508
113509
113510
113511
113512
113513
113514
113515
113516
113517
113518
113519
113520
 
# File 'ext/ctp/ctp.cxx', line 113499

SWIGINTERN VALUE
_wrap_CThostFtdcParkedOrderField_OrderPriceType_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcParkedOrderField *arg1 = (CThostFtdcParkedOrderField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcOrderPriceTypeType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcParkedOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcParkedOrderField *","OrderPriceType", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcParkedOrderField * >(argp1);
  result = (TThostFtdcOrderPriceTypeType) ((arg1)->OrderPriceType);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#OrderPriceType=(*args) ⇒ Object 



113470
113471
113472
113473
113474
113475
113476
113477
113478
113479
113480
113481
113482
113483
113484
113485
113486
113487
113488
113489
113490
113491
113492
113493
113494
113495
113496
 
# File 'ext/ctp/ctp.cxx', line 113470

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

#OrderRef(*args) ⇒ Object 



113380
113381
113382
113383
113384
113385
113386
113387
113388
113389
113390
113391
113392
113393
113394
113395
113396
113397
113398
113399
113400
113401
113402
113403
113404
113405
113406
113407
 
# File 'ext/ctp/ctp.cxx', line 113380

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



113350
113351
113352
113353
113354
113355
113356
113357
113358
113359
113360
113361
113362
113363
113364
113365
113366
113367
113368
113369
113370
113371
113372
113373
113374
113375
113376
113377
 
# File 'ext/ctp/ctp.cxx', line 113350

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

#ParkedOrderID(*args) ⇒ Object 



114489
114490
114491
114492
114493
114494
114495
114496
114497
114498
114499
114500
114501
114502
114503
114504
114505
114506
114507
114508
114509
114510
114511
114512
114513
114514
114515
114516
 
# File 'ext/ctp/ctp.cxx', line 114489

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

#ParkedOrderID=(*args) ⇒ Object 



114459
114460
114461
114462
114463
114464
114465
114466
114467
114468
114469
114470
114471
114472
114473
114474
114475
114476
114477
114478
114479
114480
114481
114482
114483
114484
114485
114486
 
# File 'ext/ctp/ctp.cxx', line 114459

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

#RequestID(*args) ⇒ Object 



114322
114323
114324
114325
114326
114327
114328
114329
114330
114331
114332
114333
114334
114335
114336
114337
114338
114339
114340
114341
114342
114343
 
# File 'ext/ctp/ctp.cxx', line 114322

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

#RequestID=(*args) ⇒ Object 



114293
114294
114295
114296
114297
114298
114299
114300
114301
114302
114303
114304
114305
114306
114307
114308
114309
114310
114311
114312
114313
114314
114315
114316
114317
114318
114319
 
# File 'ext/ctp/ctp.cxx', line 114293

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

#Status(*args) ⇒ Object 



114601
114602
114603
114604
114605
114606
114607
114608
114609
114610
114611
114612
114613
114614
114615
114616
114617
114618
114619
114620
114621
114622
 
# File 'ext/ctp/ctp.cxx', line 114601

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

#Status=(*args) ⇒ Object 



114572
114573
114574
114575
114576
114577
114578
114579
114580
114581
114582
114583
114584
114585
114586
114587
114588
114589
114590
114591
114592
114593
114594
114595
114596
114597
114598
 
# File 'ext/ctp/ctp.cxx', line 114572

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

#StopPrice(*args) ⇒ Object 



114103
114104
114105
114106
114107
114108
114109
114110
114111
114112
114113
114114
114115
114116
114117
114118
114119
114120
114121
114122
114123
114124
 
# File 'ext/ctp/ctp.cxx', line 114103

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

#StopPrice=(*args) ⇒ Object 



114074
114075
114076
114077
114078
114079
114080
114081
114082
114083
114084
114085
114086
114087
114088
114089
114090
114091
114092
114093
114094
114095
114096
114097
114098
114099
114100
 
# File 'ext/ctp/ctp.cxx', line 114074

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

#TimeCondition(*args) ⇒ Object 



113831
113832
113833
113834
113835
113836
113837
113838
113839
113840
113841
113842
113843
113844
113845
113846
113847
113848
113849
113850
113851
113852
 
# File 'ext/ctp/ctp.cxx', line 113831

SWIGINTERN VALUE
_wrap_CThostFtdcParkedOrderField_TimeCondition_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcParkedOrderField *arg1 = (CThostFtdcParkedOrderField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcTimeConditionType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcParkedOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcParkedOrderField *","TimeCondition", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcParkedOrderField * >(argp1);
  result = (TThostFtdcTimeConditionType) ((arg1)->TimeCondition);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#TimeCondition=(*args) ⇒ Object 



113802
113803
113804
113805
113806
113807
113808
113809
113810
113811
113812
113813
113814
113815
113816
113817
113818
113819
113820
113821
113822
113823
113824
113825
113826
113827
113828
 
# File 'ext/ctp/ctp.cxx', line 113802

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

#UserForceClose(*args) ⇒ Object 



114375
114376
114377
114378
114379
114380
114381
114382
114383
114384
114385
114386
114387
114388
114389
114390
114391
114392
114393
114394
114395
114396
 
# File 'ext/ctp/ctp.cxx', line 114375

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

#UserForceClose=(*args) ⇒ Object 



114346
114347
114348
114349
114350
114351
114352
114353
114354
114355
114356
114357
114358
114359
114360
114361
114362
114363
114364
114365
114366
114367
114368
114369
114370
114371
114372
 
# File 'ext/ctp/ctp.cxx', line 114346

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

#UserID(*args) ⇒ Object 



113440
113441
113442
113443
113444
113445
113446
113447
113448
113449
113450
113451
113452
113453
113454
113455
113456
113457
113458
113459
113460
113461
113462
113463
113464
113465
113466
113467
 
# File 'ext/ctp/ctp.cxx', line 113440

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



113410
113411
113412
113413
113414
113415
113416
113417
113418
113419
113420
113421
113422
113423
113424
113425
113426
113427
113428
113429
113430
113431
113432
113433
113434
113435
113436
113437
 
# File 'ext/ctp/ctp.cxx', line 113410

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

#UserType(*args) ⇒ Object 



114548
114549
114550
114551
114552
114553
114554
114555
114556
114557
114558
114559
114560
114561
114562
114563
114564
114565
114566
114567
114568
114569
 
# File 'ext/ctp/ctp.cxx', line 114548

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

#UserType=(*args) ⇒ Object 



114519
114520
114521
114522
114523
114524
114525
114526
114527
114528
114529
114530
114531
114532
114533
114534
114535
114536
114537
114538
114539
114540
114541
114542
114543
114544
114545
 
# File 'ext/ctp/ctp.cxx', line 114519

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

#VolumeCondition(*args) ⇒ Object 



113944
113945
113946
113947
113948
113949
113950
113951
113952
113953
113954
113955
113956
113957
113958
113959
113960
113961
113962
113963
113964
113965
 
# File 'ext/ctp/ctp.cxx', line 113944

SWIGINTERN VALUE
_wrap_CThostFtdcParkedOrderField_VolumeCondition_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcParkedOrderField *arg1 = (CThostFtdcParkedOrderField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TThostFtdcVolumeConditionType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CThostFtdcParkedOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcParkedOrderField *","VolumeCondition", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcParkedOrderField * >(argp1);
  result = (TThostFtdcVolumeConditionType) ((arg1)->VolumeCondition);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}

#VolumeCondition=(*args) ⇒ Object 



113915
113916
113917
113918
113919
113920
113921
113922
113923
113924
113925
113926
113927
113928
113929
113930
113931
113932
113933
113934
113935
113936
113937
113938
113939
113940
113941
 
# File 'ext/ctp/ctp.cxx', line 113915

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

#VolumeTotalOriginal(*args) ⇒ Object 



113778
113779
113780
113781
113782
113783
113784
113785
113786
113787
113788
113789
113790
113791
113792
113793
113794
113795
113796
113797
113798
113799
 
# File 'ext/ctp/ctp.cxx', line 113778

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

#VolumeTotalOriginal=(*args) ⇒ Object 



113749
113750
113751
113752
113753
113754
113755
113756
113757
113758
113759
113760
113761
113762
113763
113764
113765
113766
113767
113768
113769
113770
113771
113772
113773
113774
113775
 
# File 'ext/ctp/ctp.cxx', line 113749

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