Class: Ctp::CThostFtdcQueryMaxOrderVolumeWithPriceField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



126705
126706
126707
126708
126709
126710
126711
126712
126713
126714
126715
126716
126717
126718
 
# File 'ext/ctp/ctp.cxx', line 126705

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

Instance Method Details

#BrokerID(*args) ⇒ Object 



126275
126276
126277
126278
126279
126280
126281
126282
126283
126284
126285
126286
126287
126288
126289
126290
126291
126292
126293
126294
126295
126296
126297
126298
126299
126300
126301
126302
 
# File 'ext/ctp/ctp.cxx', line 126275

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

#BrokerID=(*args) ⇒ Object 



126245
126246
126247
126248
126249
126250
126251
126252
126253
126254
126255
126256
126257
126258
126259
126260
126261
126262
126263
126264
126265
126266
126267
126268
126269
126270
126271
126272
 
# File 'ext/ctp/ctp.cxx', line 126245

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

#Direction(*args) ⇒ Object 



126454
126455
126456
126457
126458
126459
126460
126461
126462
126463
126464
126465
126466
126467
126468
126469
126470
126471
126472
126473
126474
126475
 
# File 'ext/ctp/ctp.cxx', line 126454

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

#Direction=(*args) ⇒ Object 



126425
126426
126427
126428
126429
126430
126431
126432
126433
126434
126435
126436
126437
126438
126439
126440
126441
126442
126443
126444
126445
126446
126447
126448
126449
126450
126451
 
# File 'ext/ctp/ctp.cxx', line 126425

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

#HedgeFlag(*args) ⇒ Object 



126560
126561
126562
126563
126564
126565
126566
126567
126568
126569
126570
126571
126572
126573
126574
126575
126576
126577
126578
126579
126580
126581
 
# File 'ext/ctp/ctp.cxx', line 126560

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

#HedgeFlag=(*args) ⇒ Object 



126531
126532
126533
126534
126535
126536
126537
126538
126539
126540
126541
126542
126543
126544
126545
126546
126547
126548
126549
126550
126551
126552
126553
126554
126555
126556
126557
 
# File 'ext/ctp/ctp.cxx', line 126531

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

#InstrumentID(*args) ⇒ Object 



126395
126396
126397
126398
126399
126400
126401
126402
126403
126404
126405
126406
126407
126408
126409
126410
126411
126412
126413
126414
126415
126416
126417
126418
126419
126420
126421
126422
 
# File 'ext/ctp/ctp.cxx', line 126395

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



126365
126366
126367
126368
126369
126370
126371
126372
126373
126374
126375
126376
126377
126378
126379
126380
126381
126382
126383
126384
126385
126386
126387
126388
126389
126390
126391
126392
 
# File 'ext/ctp/ctp.cxx', line 126365

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

#InvestorID(*args) ⇒ Object 



126335
126336
126337
126338
126339
126340
126341
126342
126343
126344
126345
126346
126347
126348
126349
126350
126351
126352
126353
126354
126355
126356
126357
126358
126359
126360
126361
126362
 
# File 'ext/ctp/ctp.cxx', line 126335

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

#InvestorID=(*args) ⇒ Object 



126305
126306
126307
126308
126309
126310
126311
126312
126313
126314
126315
126316
126317
126318
126319
126320
126321
126322
126323
126324
126325
126326
126327
126328
126329
126330
126331
126332
 
# File 'ext/ctp/ctp.cxx', line 126305

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

#MaxVolume(*args) ⇒ Object 



126613
126614
126615
126616
126617
126618
126619
126620
126621
126622
126623
126624
126625
126626
126627
126628
126629
126630
126631
126632
126633
126634
 
# File 'ext/ctp/ctp.cxx', line 126613

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

#MaxVolume=(*args) ⇒ Object 



126584
126585
126586
126587
126588
126589
126590
126591
126592
126593
126594
126595
126596
126597
126598
126599
126600
126601
126602
126603
126604
126605
126606
126607
126608
126609
126610
 
# File 'ext/ctp/ctp.cxx', line 126584

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

#OffsetFlag(*args) ⇒ Object 



126507
126508
126509
126510
126511
126512
126513
126514
126515
126516
126517
126518
126519
126520
126521
126522
126523
126524
126525
126526
126527
126528
 
# File 'ext/ctp/ctp.cxx', line 126507

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

#OffsetFlag=(*args) ⇒ Object 



126478
126479
126480
126481
126482
126483
126484
126485
126486
126487
126488
126489
126490
126491
126492
126493
126494
126495
126496
126497
126498
126499
126500
126501
126502
126503
126504
 
# File 'ext/ctp/ctp.cxx', line 126478

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

#Price(*args) ⇒ Object 



126666
126667
126668
126669
126670
126671
126672
126673
126674
126675
126676
126677
126678
126679
126680
126681
126682
126683
126684
126685
126686
126687
 
# File 'ext/ctp/ctp.cxx', line 126666

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

#Price=(*args) ⇒ Object 



126637
126638
126639
126640
126641
126642
126643
126644
126645
126646
126647
126648
126649
126650
126651
126652
126653
126654
126655
126656
126657
126658
126659
126660
126661
126662
126663
 
# File 'ext/ctp/ctp.cxx', line 126637

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