Class: Ctp::CThostFtdcDepthMarketDataField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



25425
25426
25427
25428
25429
25430
25431
25432
25433
25434
25435
25436
25437
25438
 
# File 'ext/ctp/ctp.cxx', line 25425

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

Instance Method Details

#ActionDay(*args) ⇒ Object 



25380
25381
25382
25383
25384
25385
25386
25387
25388
25389
25390
25391
25392
25393
25394
25395
25396
25397
25398
25399
25400
25401
25402
25403
25404
25405
25406
25407
 
# File 'ext/ctp/ctp.cxx', line 25380

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

#ActionDay=(*args) ⇒ Object 



25350
25351
25352
25353
25354
25355
25356
25357
25358
25359
25360
25361
25362
25363
25364
25365
25366
25367
25368
25369
25370
25371
25372
25373
25374
25375
25376
25377
 
# File 'ext/ctp/ctp.cxx', line 25350

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

#AskPrice1(*args) ⇒ Object 



24372
24373
24374
24375
24376
24377
24378
24379
24380
24381
24382
24383
24384
24385
24386
24387
24388
24389
24390
24391
24392
24393
 
# File 'ext/ctp/ctp.cxx', line 24372

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

#AskPrice1=(*args) ⇒ Object 



24343
24344
24345
24346
24347
24348
24349
24350
24351
24352
24353
24354
24355
24356
24357
24358
24359
24360
24361
24362
24363
24364
24365
24366
24367
24368
24369
 
# File 'ext/ctp/ctp.cxx', line 24343

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

#AskPrice2(*args) ⇒ Object 



24584
24585
24586
24587
24588
24589
24590
24591
24592
24593
24594
24595
24596
24597
24598
24599
24600
24601
24602
24603
24604
24605
 
# File 'ext/ctp/ctp.cxx', line 24584

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

#AskPrice2=(*args) ⇒ Object 



24555
24556
24557
24558
24559
24560
24561
24562
24563
24564
24565
24566
24567
24568
24569
24570
24571
24572
24573
24574
24575
24576
24577
24578
24579
24580
24581
 
# File 'ext/ctp/ctp.cxx', line 24555

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

#AskPrice3(*args) ⇒ Object 



24796
24797
24798
24799
24800
24801
24802
24803
24804
24805
24806
24807
24808
24809
24810
24811
24812
24813
24814
24815
24816
24817
 
# File 'ext/ctp/ctp.cxx', line 24796

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

#AskPrice3=(*args) ⇒ Object 



24767
24768
24769
24770
24771
24772
24773
24774
24775
24776
24777
24778
24779
24780
24781
24782
24783
24784
24785
24786
24787
24788
24789
24790
24791
24792
24793
 
# File 'ext/ctp/ctp.cxx', line 24767

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

#AskPrice4(*args) ⇒ Object 



25008
25009
25010
25011
25012
25013
25014
25015
25016
25017
25018
25019
25020
25021
25022
25023
25024
25025
25026
25027
25028
25029
 
# File 'ext/ctp/ctp.cxx', line 25008

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

#AskPrice4=(*args) ⇒ Object 



24979
24980
24981
24982
24983
24984
24985
24986
24987
24988
24989
24990
24991
24992
24993
24994
24995
24996
24997
24998
24999
25000
25001
25002
25003
25004
25005
 
# File 'ext/ctp/ctp.cxx', line 24979

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

#AskPrice5(*args) ⇒ Object 



25220
25221
25222
25223
25224
25225
25226
25227
25228
25229
25230
25231
25232
25233
25234
25235
25236
25237
25238
25239
25240
25241
 
# File 'ext/ctp/ctp.cxx', line 25220

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

#AskPrice5=(*args) ⇒ Object 



25191
25192
25193
25194
25195
25196
25197
25198
25199
25200
25201
25202
25203
25204
25205
25206
25207
25208
25209
25210
25211
25212
25213
25214
25215
25216
25217
 
# File 'ext/ctp/ctp.cxx', line 25191

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

#AskVolume1(*args) ⇒ Object 



24425
24426
24427
24428
24429
24430
24431
24432
24433
24434
24435
24436
24437
24438
24439
24440
24441
24442
24443
24444
24445
24446
 
# File 'ext/ctp/ctp.cxx', line 24425

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

#AskVolume1=(*args) ⇒ Object 



24396
24397
24398
24399
24400
24401
24402
24403
24404
24405
24406
24407
24408
24409
24410
24411
24412
24413
24414
24415
24416
24417
24418
24419
24420
24421
24422
 
# File 'ext/ctp/ctp.cxx', line 24396

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

#AskVolume2(*args) ⇒ Object 



24637
24638
24639
24640
24641
24642
24643
24644
24645
24646
24647
24648
24649
24650
24651
24652
24653
24654
24655
24656
24657
24658
 
# File 'ext/ctp/ctp.cxx', line 24637

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

#AskVolume2=(*args) ⇒ Object 



24608
24609
24610
24611
24612
24613
24614
24615
24616
24617
24618
24619
24620
24621
24622
24623
24624
24625
24626
24627
24628
24629
24630
24631
24632
24633
24634
 
# File 'ext/ctp/ctp.cxx', line 24608

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

#AskVolume3(*args) ⇒ Object 



24849
24850
24851
24852
24853
24854
24855
24856
24857
24858
24859
24860
24861
24862
24863
24864
24865
24866
24867
24868
24869
24870
 
# File 'ext/ctp/ctp.cxx', line 24849

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

#AskVolume3=(*args) ⇒ Object 



24820
24821
24822
24823
24824
24825
24826
24827
24828
24829
24830
24831
24832
24833
24834
24835
24836
24837
24838
24839
24840
24841
24842
24843
24844
24845
24846
 
# File 'ext/ctp/ctp.cxx', line 24820

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

#AskVolume4(*args) ⇒ Object 



25061
25062
25063
25064
25065
25066
25067
25068
25069
25070
25071
25072
25073
25074
25075
25076
25077
25078
25079
25080
25081
25082
 
# File 'ext/ctp/ctp.cxx', line 25061

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

#AskVolume4=(*args) ⇒ Object 



25032
25033
25034
25035
25036
25037
25038
25039
25040
25041
25042
25043
25044
25045
25046
25047
25048
25049
25050
25051
25052
25053
25054
25055
25056
25057
25058
 
# File 'ext/ctp/ctp.cxx', line 25032

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

#AskVolume5(*args) ⇒ Object 



25273
25274
25275
25276
25277
25278
25279
25280
25281
25282
25283
25284
25285
25286
25287
25288
25289
25290
25291
25292
25293
25294
 
# File 'ext/ctp/ctp.cxx', line 25273

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

#AskVolume5=(*args) ⇒ Object 



25244
25245
25246
25247
25248
25249
25250
25251
25252
25253
25254
25255
25256
25257
25258
25259
25260
25261
25262
25263
25264
25265
25266
25267
25268
25269
25270
 
# File 'ext/ctp/ctp.cxx', line 25244

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

#AveragePrice(*args) ⇒ Object 



25326
25327
25328
25329
25330
25331
25332
25333
25334
25335
25336
25337
25338
25339
25340
25341
25342
25343
25344
25345
25346
25347
 
# File 'ext/ctp/ctp.cxx', line 25326

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

#AveragePrice=(*args) ⇒ Object 



25297
25298
25299
25300
25301
25302
25303
25304
25305
25306
25307
25308
25309
25310
25311
25312
25313
25314
25315
25316
25317
25318
25319
25320
25321
25322
25323
 
# File 'ext/ctp/ctp.cxx', line 25297

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

#BidPrice1(*args) ⇒ Object 



24266
24267
24268
24269
24270
24271
24272
24273
24274
24275
24276
24277
24278
24279
24280
24281
24282
24283
24284
24285
24286
24287
 
# File 'ext/ctp/ctp.cxx', line 24266

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

#BidPrice1=(*args) ⇒ Object 



24237
24238
24239
24240
24241
24242
24243
24244
24245
24246
24247
24248
24249
24250
24251
24252
24253
24254
24255
24256
24257
24258
24259
24260
24261
24262
24263
 
# File 'ext/ctp/ctp.cxx', line 24237

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

#BidPrice2(*args) ⇒ Object 



24478
24479
24480
24481
24482
24483
24484
24485
24486
24487
24488
24489
24490
24491
24492
24493
24494
24495
24496
24497
24498
24499
 
# File 'ext/ctp/ctp.cxx', line 24478

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

#BidPrice2=(*args) ⇒ Object 



24449
24450
24451
24452
24453
24454
24455
24456
24457
24458
24459
24460
24461
24462
24463
24464
24465
24466
24467
24468
24469
24470
24471
24472
24473
24474
24475
 
# File 'ext/ctp/ctp.cxx', line 24449

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

#BidPrice3(*args) ⇒ Object 



24690
24691
24692
24693
24694
24695
24696
24697
24698
24699
24700
24701
24702
24703
24704
24705
24706
24707
24708
24709
24710
24711
 
# File 'ext/ctp/ctp.cxx', line 24690

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

#BidPrice3=(*args) ⇒ Object 



24661
24662
24663
24664
24665
24666
24667
24668
24669
24670
24671
24672
24673
24674
24675
24676
24677
24678
24679
24680
24681
24682
24683
24684
24685
24686
24687
 
# File 'ext/ctp/ctp.cxx', line 24661

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

#BidPrice4(*args) ⇒ Object 



24902
24903
24904
24905
24906
24907
24908
24909
24910
24911
24912
24913
24914
24915
24916
24917
24918
24919
24920
24921
24922
24923
 
# File 'ext/ctp/ctp.cxx', line 24902

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

#BidPrice4=(*args) ⇒ Object 



24873
24874
24875
24876
24877
24878
24879
24880
24881
24882
24883
24884
24885
24886
24887
24888
24889
24890
24891
24892
24893
24894
24895
24896
24897
24898
24899
 
# File 'ext/ctp/ctp.cxx', line 24873

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

#BidPrice5(*args) ⇒ Object 



25114
25115
25116
25117
25118
25119
25120
25121
25122
25123
25124
25125
25126
25127
25128
25129
25130
25131
25132
25133
25134
25135
 
# File 'ext/ctp/ctp.cxx', line 25114

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

#BidPrice5=(*args) ⇒ Object 



25085
25086
25087
25088
25089
25090
25091
25092
25093
25094
25095
25096
25097
25098
25099
25100
25101
25102
25103
25104
25105
25106
25107
25108
25109
25110
25111
 
# File 'ext/ctp/ctp.cxx', line 25085

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

#BidVolume1(*args) ⇒ Object 



24319
24320
24321
24322
24323
24324
24325
24326
24327
24328
24329
24330
24331
24332
24333
24334
24335
24336
24337
24338
24339
24340
 
# File 'ext/ctp/ctp.cxx', line 24319

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

#BidVolume1=(*args) ⇒ Object 



24290
24291
24292
24293
24294
24295
24296
24297
24298
24299
24300
24301
24302
24303
24304
24305
24306
24307
24308
24309
24310
24311
24312
24313
24314
24315
24316
 
# File 'ext/ctp/ctp.cxx', line 24290

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

#BidVolume2(*args) ⇒ Object 



24531
24532
24533
24534
24535
24536
24537
24538
24539
24540
24541
24542
24543
24544
24545
24546
24547
24548
24549
24550
24551
24552
 
# File 'ext/ctp/ctp.cxx', line 24531

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

#BidVolume2=(*args) ⇒ Object 



24502
24503
24504
24505
24506
24507
24508
24509
24510
24511
24512
24513
24514
24515
24516
24517
24518
24519
24520
24521
24522
24523
24524
24525
24526
24527
24528
 
# File 'ext/ctp/ctp.cxx', line 24502

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

#BidVolume3(*args) ⇒ Object 



24743
24744
24745
24746
24747
24748
24749
24750
24751
24752
24753
24754
24755
24756
24757
24758
24759
24760
24761
24762
24763
24764
 
# File 'ext/ctp/ctp.cxx', line 24743

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

#BidVolume3=(*args) ⇒ Object 



24714
24715
24716
24717
24718
24719
24720
24721
24722
24723
24724
24725
24726
24727
24728
24729
24730
24731
24732
24733
24734
24735
24736
24737
24738
24739
24740
 
# File 'ext/ctp/ctp.cxx', line 24714

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

#BidVolume4(*args) ⇒ Object 



24955
24956
24957
24958
24959
24960
24961
24962
24963
24964
24965
24966
24967
24968
24969
24970
24971
24972
24973
24974
24975
24976
 
# File 'ext/ctp/ctp.cxx', line 24955

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

#BidVolume4=(*args) ⇒ Object 



24926
24927
24928
24929
24930
24931
24932
24933
24934
24935
24936
24937
24938
24939
24940
24941
24942
24943
24944
24945
24946
24947
24948
24949
24950
24951
24952
 
# File 'ext/ctp/ctp.cxx', line 24926

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

#BidVolume5(*args) ⇒ Object 



25167
25168
25169
25170
25171
25172
25173
25174
25175
25176
25177
25178
25179
25180
25181
25182
25183
25184
25185
25186
25187
25188
 
# File 'ext/ctp/ctp.cxx', line 25167

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

#BidVolume5=(*args) ⇒ Object 



25138
25139
25140
25141
25142
25143
25144
25145
25146
25147
25148
25149
25150
25151
25152
25153
25154
25155
25156
25157
25158
25159
25160
25161
25162
25163
25164
 
# File 'ext/ctp/ctp.cxx', line 25138

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

#ClosePrice(*args) ⇒ Object 



23835
23836
23837
23838
23839
23840
23841
23842
23843
23844
23845
23846
23847
23848
23849
23850
23851
23852
23853
23854
23855
23856
 
# File 'ext/ctp/ctp.cxx', line 23835

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

#ClosePrice=(*args) ⇒ Object 



23806
23807
23808
23809
23810
23811
23812
23813
23814
23815
23816
23817
23818
23819
23820
23821
23822
23823
23824
23825
23826
23827
23828
23829
23830
23831
23832
 
# File 'ext/ctp/ctp.cxx', line 23806

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

#CurrDelta(*args) ⇒ Object 



24100
24101
24102
24103
24104
24105
24106
24107
24108
24109
24110
24111
24112
24113
24114
24115
24116
24117
24118
24119
24120
24121
 
# File 'ext/ctp/ctp.cxx', line 24100

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

#CurrDelta=(*args) ⇒ Object 



24071
24072
24073
24074
24075
24076
24077
24078
24079
24080
24081
24082
24083
24084
24085
24086
24087
24088
24089
24090
24091
24092
24093
24094
24095
24096
24097
 
# File 'ext/ctp/ctp.cxx', line 24071

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

#ExchangeID(*args) ⇒ Object 



23186
23187
23188
23189
23190
23191
23192
23193
23194
23195
23196
23197
23198
23199
23200
23201
23202
23203
23204
23205
23206
23207
23208
23209
23210
23211
23212
23213
 
# File 'ext/ctp/ctp.cxx', line 23186

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



23156
23157
23158
23159
23160
23161
23162
23163
23164
23165
23166
23167
23168
23169
23170
23171
23172
23173
23174
23175
23176
23177
23178
23179
23180
23181
23182
23183
 
# File 'ext/ctp/ctp.cxx', line 23156

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

#ExchangeInstID(*args) ⇒ Object 



23246
23247
23248
23249
23250
23251
23252
23253
23254
23255
23256
23257
23258
23259
23260
23261
23262
23263
23264
23265
23266
23267
23268
23269
23270
23271
23272
23273
 
# File 'ext/ctp/ctp.cxx', line 23246

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

#ExchangeInstID=(*args) ⇒ Object 



23216
23217
23218
23219
23220
23221
23222
23223
23224
23225
23226
23227
23228
23229
23230
23231
23232
23233
23234
23235
23236
23237
23238
23239
23240
23241
23242
23243
 
# File 'ext/ctp/ctp.cxx', line 23216

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

#HighestPrice(*args) ⇒ Object 



23570
23571
23572
23573
23574
23575
23576
23577
23578
23579
23580
23581
23582
23583
23584
23585
23586
23587
23588
23589
23590
23591
 
# File 'ext/ctp/ctp.cxx', line 23570

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

#HighestPrice=(*args) ⇒ Object 



23541
23542
23543
23544
23545
23546
23547
23548
23549
23550
23551
23552
23553
23554
23555
23556
23557
23558
23559
23560
23561
23562
23563
23564
23565
23566
23567
 
# File 'ext/ctp/ctp.cxx', line 23541

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

#InstrumentID(*args) ⇒ Object 



23126
23127
23128
23129
23130
23131
23132
23133
23134
23135
23136
23137
23138
23139
23140
23141
23142
23143
23144
23145
23146
23147
23148
23149
23150
23151
23152
23153
 
# File 'ext/ctp/ctp.cxx', line 23126

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



23096
23097
23098
23099
23100
23101
23102
23103
23104
23105
23106
23107
23108
23109
23110
23111
23112
23113
23114
23115
23116
23117
23118
23119
23120
23121
23122
23123
 
# File 'ext/ctp/ctp.cxx', line 23096

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

#LastPrice(*args) ⇒ Object 



23305
23306
23307
23308
23309
23310
23311
23312
23313
23314
23315
23316
23317
23318
23319
23320
23321
23322
23323
23324
23325
23326
 
# File 'ext/ctp/ctp.cxx', line 23305

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

#LastPrice=(*args) ⇒ Object 



23276
23277
23278
23279
23280
23281
23282
23283
23284
23285
23286
23287
23288
23289
23290
23291
23292
23293
23294
23295
23296
23297
23298
23299
23300
23301
23302
 
# File 'ext/ctp/ctp.cxx', line 23276

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

#LowerLimitPrice(*args) ⇒ Object 



23994
23995
23996
23997
23998
23999
24000
24001
24002
24003
24004
24005
24006
24007
24008
24009
24010
24011
24012
24013
24014
24015
 
# File 'ext/ctp/ctp.cxx', line 23994

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

#LowerLimitPrice=(*args) ⇒ Object 



23965
23966
23967
23968
23969
23970
23971
23972
23973
23974
23975
23976
23977
23978
23979
23980
23981
23982
23983
23984
23985
23986
23987
23988
23989
23990
23991
 
# File 'ext/ctp/ctp.cxx', line 23965

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

#LowestPrice(*args) ⇒ Object 



23623
23624
23625
23626
23627
23628
23629
23630
23631
23632
23633
23634
23635
23636
23637
23638
23639
23640
23641
23642
23643
23644
 
# File 'ext/ctp/ctp.cxx', line 23623

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

#LowestPrice=(*args) ⇒ Object 



23594
23595
23596
23597
23598
23599
23600
23601
23602
23603
23604
23605
23606
23607
23608
23609
23610
23611
23612
23613
23614
23615
23616
23617
23618
23619
23620
 
# File 'ext/ctp/ctp.cxx', line 23594

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

#OpenInterest(*args) ⇒ Object 



23782
23783
23784
23785
23786
23787
23788
23789
23790
23791
23792
23793
23794
23795
23796
23797
23798
23799
23800
23801
23802
23803
 
# File 'ext/ctp/ctp.cxx', line 23782

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

#OpenInterest=(*args) ⇒ Object 



23753
23754
23755
23756
23757
23758
23759
23760
23761
23762
23763
23764
23765
23766
23767
23768
23769
23770
23771
23772
23773
23774
23775
23776
23777
23778
23779
 
# File 'ext/ctp/ctp.cxx', line 23753

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

#OpenPrice(*args) ⇒ Object 



23517
23518
23519
23520
23521
23522
23523
23524
23525
23526
23527
23528
23529
23530
23531
23532
23533
23534
23535
23536
23537
23538
 
# File 'ext/ctp/ctp.cxx', line 23517

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

#OpenPrice=(*args) ⇒ Object 



23488
23489
23490
23491
23492
23493
23494
23495
23496
23497
23498
23499
23500
23501
23502
23503
23504
23505
23506
23507
23508
23509
23510
23511
23512
23513
23514
 
# File 'ext/ctp/ctp.cxx', line 23488

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

#PreClosePrice(*args) ⇒ Object 



23411
23412
23413
23414
23415
23416
23417
23418
23419
23420
23421
23422
23423
23424
23425
23426
23427
23428
23429
23430
23431
23432
 
# File 'ext/ctp/ctp.cxx', line 23411

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

#PreClosePrice=(*args) ⇒ Object 



23382
23383
23384
23385
23386
23387
23388
23389
23390
23391
23392
23393
23394
23395
23396
23397
23398
23399
23400
23401
23402
23403
23404
23405
23406
23407
23408
 
# File 'ext/ctp/ctp.cxx', line 23382

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

#PreDelta(*args) ⇒ Object 



24047
24048
24049
24050
24051
24052
24053
24054
24055
24056
24057
24058
24059
24060
24061
24062
24063
24064
24065
24066
24067
24068
 
# File 'ext/ctp/ctp.cxx', line 24047

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

#PreDelta=(*args) ⇒ Object 



24018
24019
24020
24021
24022
24023
24024
24025
24026
24027
24028
24029
24030
24031
24032
24033
24034
24035
24036
24037
24038
24039
24040
24041
24042
24043
24044
 
# File 'ext/ctp/ctp.cxx', line 24018

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

#PreOpenInterest(*args) ⇒ Object 



23464
23465
23466
23467
23468
23469
23470
23471
23472
23473
23474
23475
23476
23477
23478
23479
23480
23481
23482
23483
23484
23485
 
# File 'ext/ctp/ctp.cxx', line 23464

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

#PreOpenInterest=(*args) ⇒ Object 



23435
23436
23437
23438
23439
23440
23441
23442
23443
23444
23445
23446
23447
23448
23449
23450
23451
23452
23453
23454
23455
23456
23457
23458
23459
23460
23461
 
# File 'ext/ctp/ctp.cxx', line 23435

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

#PreSettlementPrice(*args) ⇒ Object 



23358
23359
23360
23361
23362
23363
23364
23365
23366
23367
23368
23369
23370
23371
23372
23373
23374
23375
23376
23377
23378
23379
 
# File 'ext/ctp/ctp.cxx', line 23358

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

#PreSettlementPrice=(*args) ⇒ Object 



23329
23330
23331
23332
23333
23334
23335
23336
23337
23338
23339
23340
23341
23342
23343
23344
23345
23346
23347
23348
23349
23350
23351
23352
23353
23354
23355
 
# File 'ext/ctp/ctp.cxx', line 23329

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

#SettlementPrice(*args) ⇒ Object 



23888
23889
23890
23891
23892
23893
23894
23895
23896
23897
23898
23899
23900
23901
23902
23903
23904
23905
23906
23907
23908
23909
 
# File 'ext/ctp/ctp.cxx', line 23888

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

#SettlementPrice=(*args) ⇒ Object 



23859
23860
23861
23862
23863
23864
23865
23866
23867
23868
23869
23870
23871
23872
23873
23874
23875
23876
23877
23878
23879
23880
23881
23882
23883
23884
23885
 
# File 'ext/ctp/ctp.cxx', line 23859

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

#TradingDay(*args) ⇒ Object 



23066
23067
23068
23069
23070
23071
23072
23073
23074
23075
23076
23077
23078
23079
23080
23081
23082
23083
23084
23085
23086
23087
23088
23089
23090
23091
23092
23093
 
# File 'ext/ctp/ctp.cxx', line 23066

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

#TradingDay=(*args) ⇒ Object 



23036
23037
23038
23039
23040
23041
23042
23043
23044
23045
23046
23047
23048
23049
23050
23051
23052
23053
23054
23055
23056
23057
23058
23059
23060
23061
23062
23063
 
# File 'ext/ctp/ctp.cxx', line 23036

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

#Turnover(*args) ⇒ Object 



23729
23730
23731
23732
23733
23734
23735
23736
23737
23738
23739
23740
23741
23742
23743
23744
23745
23746
23747
23748
23749
23750
 
# File 'ext/ctp/ctp.cxx', line 23729

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

#Turnover=(*args) ⇒ Object 



23700
23701
23702
23703
23704
23705
23706
23707
23708
23709
23710
23711
23712
23713
23714
23715
23716
23717
23718
23719
23720
23721
23722
23723
23724
23725
23726
 
# File 'ext/ctp/ctp.cxx', line 23700

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

#UpdateMillisec(*args) ⇒ Object 



24213
24214
24215
24216
24217
24218
24219
24220
24221
24222
24223
24224
24225
24226
24227
24228
24229
24230
24231
24232
24233
24234
 
# File 'ext/ctp/ctp.cxx', line 24213

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

#UpdateMillisec=(*args) ⇒ Object 



24184
24185
24186
24187
24188
24189
24190
24191
24192
24193
24194
24195
24196
24197
24198
24199
24200
24201
24202
24203
24204
24205
24206
24207
24208
24209
24210
 
# File 'ext/ctp/ctp.cxx', line 24184

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

#UpdateTime(*args) ⇒ Object 



24154
24155
24156
24157
24158
24159
24160
24161
24162
24163
24164
24165
24166
24167
24168
24169
24170
24171
24172
24173
24174
24175
24176
24177
24178
24179
24180
24181
 
# File 'ext/ctp/ctp.cxx', line 24154

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

#UpdateTime=(*args) ⇒ Object 



24124
24125
24126
24127
24128
24129
24130
24131
24132
24133
24134
24135
24136
24137
24138
24139
24140
24141
24142
24143
24144
24145
24146
24147
24148
24149
24150
24151
 
# File 'ext/ctp/ctp.cxx', line 24124

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

#UpperLimitPrice(*args) ⇒ Object 



23941
23942
23943
23944
23945
23946
23947
23948
23949
23950
23951
23952
23953
23954
23955
23956
23957
23958
23959
23960
23961
23962
 
# File 'ext/ctp/ctp.cxx', line 23941

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

#UpperLimitPrice=(*args) ⇒ Object 



23912
23913
23914
23915
23916
23917
23918
23919
23920
23921
23922
23923
23924
23925
23926
23927
23928
23929
23930
23931
23932
23933
23934
23935
23936
23937
23938
 
# File 'ext/ctp/ctp.cxx', line 23912

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

#Volume(*args) ⇒ Object 



23676
23677
23678
23679
23680
23681
23682
23683
23684
23685
23686
23687
23688
23689
23690
23691
23692
23693
23694
23695
23696
23697
 
# File 'ext/ctp/ctp.cxx', line 23676

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

#Volume=(*args) ⇒ Object 



23647
23648
23649
23650
23651
23652
23653
23654
23655
23656
23657
23658
23659
23660
23661
23662
23663
23664
23665
23666
23667
23668
23669
23670
23671
23672
23673
 
# File 'ext/ctp/ctp.cxx', line 23647

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