Class: Ctp::CThostFtdcSyncingInvestorPositionField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



55690
55691
55692
55693
55694
55695
55696
55697
55698
55699
55700
55701
55702
55703
 
# File 'ext/ctp/ctp.cxx', line 55690

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

Instance Method Details

#AbandonFrozen(*args) ⇒ Object 



55651
55652
55653
55654
55655
55656
55657
55658
55659
55660
55661
55662
55663
55664
55665
55666
55667
55668
55669
55670
55671
55672
 
# File 'ext/ctp/ctp.cxx', line 55651

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

#AbandonFrozen=(*args) ⇒ Object 



55622
55623
55624
55625
55626
55627
55628
55629
55630
55631
55632
55633
55634
55635
55636
55637
55638
55639
55640
55641
55642
55643
55644
55645
55646
55647
55648
 
# File 'ext/ctp/ctp.cxx', line 55622

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

#BrokerID(*args) ⇒ Object 



53458
53459
53460
53461
53462
53463
53464
53465
53466
53467
53468
53469
53470
53471
53472
53473
53474
53475
53476
53477
53478
53479
53480
53481
53482
53483
53484
53485
 
# File 'ext/ctp/ctp.cxx', line 53458

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



53428
53429
53430
53431
53432
53433
53434
53435
53436
53437
53438
53439
53440
53441
53442
53443
53444
53445
53446
53447
53448
53449
53450
53451
53452
53453
53454
53455
 
# File 'ext/ctp/ctp.cxx', line 53428

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

#CashIn(*args) ⇒ Object 



54584
54585
54586
54587
54588
54589
54590
54591
54592
54593
54594
54595
54596
54597
54598
54599
54600
54601
54602
54603
54604
54605
 
# File 'ext/ctp/ctp.cxx', line 54584

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

#CashIn=(*args) ⇒ Object 



54555
54556
54557
54558
54559
54560
54561
54562
54563
54564
54565
54566
54567
54568
54569
54570
54571
54572
54573
54574
54575
54576
54577
54578
54579
54580
54581
 
# File 'ext/ctp/ctp.cxx', line 54555

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

#CloseAmount(*args) ⇒ Object 



54213
54214
54215
54216
54217
54218
54219
54220
54221
54222
54223
54224
54225
54226
54227
54228
54229
54230
54231
54232
54233
54234
 
# File 'ext/ctp/ctp.cxx', line 54213

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

#CloseAmount=(*args) ⇒ Object 



54184
54185
54186
54187
54188
54189
54190
54191
54192
54193
54194
54195
54196
54197
54198
54199
54200
54201
54202
54203
54204
54205
54206
54207
54208
54209
54210
 
# File 'ext/ctp/ctp.cxx', line 54184

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

#CloseProfit(*args) ⇒ Object 



54690
54691
54692
54693
54694
54695
54696
54697
54698
54699
54700
54701
54702
54703
54704
54705
54706
54707
54708
54709
54710
54711
 
# File 'ext/ctp/ctp.cxx', line 54690

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

#CloseProfit=(*args) ⇒ Object 



54661
54662
54663
54664
54665
54666
54667
54668
54669
54670
54671
54672
54673
54674
54675
54676
54677
54678
54679
54680
54681
54682
54683
54684
54685
54686
54687
 
# File 'ext/ctp/ctp.cxx', line 54661

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

#CloseProfitByDate(*args) ⇒ Object 



55280
55281
55282
55283
55284
55285
55286
55287
55288
55289
55290
55291
55292
55293
55294
55295
55296
55297
55298
55299
55300
55301
 
# File 'ext/ctp/ctp.cxx', line 55280

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

#CloseProfitByDate=(*args) ⇒ Object 



55251
55252
55253
55254
55255
55256
55257
55258
55259
55260
55261
55262
55263
55264
55265
55266
55267
55268
55269
55270
55271
55272
55273
55274
55275
55276
55277
 
# File 'ext/ctp/ctp.cxx', line 55251

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

#CloseProfitByTrade(*args) ⇒ Object 



55333
55334
55335
55336
55337
55338
55339
55340
55341
55342
55343
55344
55345
55346
55347
55348
55349
55350
55351
55352
55353
55354
 
# File 'ext/ctp/ctp.cxx', line 55333

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

#CloseProfitByTrade=(*args) ⇒ Object 



55304
55305
55306
55307
55308
55309
55310
55311
55312
55313
55314
55315
55316
55317
55318
55319
55320
55321
55322
55323
55324
55325
55326
55327
55328
55329
55330
 
# File 'ext/ctp/ctp.cxx', line 55304

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

#CloseVolume(*args) ⇒ Object 



54107
54108
54109
54110
54111
54112
54113
54114
54115
54116
54117
54118
54119
54120
54121
54122
54123
54124
54125
54126
54127
54128
 
# File 'ext/ctp/ctp.cxx', line 54107

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

#CloseVolume=(*args) ⇒ Object 



54078
54079
54080
54081
54082
54083
54084
54085
54086
54087
54088
54089
54090
54091
54092
54093
54094
54095
54096
54097
54098
54099
54100
54101
54102
54103
54104
 
# File 'ext/ctp/ctp.cxx', line 54078

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

#CombLongFrozen(*args) ⇒ Object 



55174
55175
55176
55177
55178
55179
55180
55181
55182
55183
55184
55185
55186
55187
55188
55189
55190
55191
55192
55193
55194
55195
 
# File 'ext/ctp/ctp.cxx', line 55174

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

#CombLongFrozen=(*args) ⇒ Object 



55145
55146
55147
55148
55149
55150
55151
55152
55153
55154
55155
55156
55157
55158
55159
55160
55161
55162
55163
55164
55165
55166
55167
55168
55169
55170
55171
 
# File 'ext/ctp/ctp.cxx', line 55145

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

#CombPosition(*args) ⇒ Object 



55121
55122
55123
55124
55125
55126
55127
55128
55129
55130
55131
55132
55133
55134
55135
55136
55137
55138
55139
55140
55141
55142
 
# File 'ext/ctp/ctp.cxx', line 55121

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

#CombPosition=(*args) ⇒ Object 



55092
55093
55094
55095
55096
55097
55098
55099
55100
55101
55102
55103
55104
55105
55106
55107
55108
55109
55110
55111
55112
55113
55114
55115
55116
55117
55118
 
# File 'ext/ctp/ctp.cxx', line 55092

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

#CombShortFrozen(*args) ⇒ Object 



55227
55228
55229
55230
55231
55232
55233
55234
55235
55236
55237
55238
55239
55240
55241
55242
55243
55244
55245
55246
55247
55248
 
# File 'ext/ctp/ctp.cxx', line 55227

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

#CombShortFrozen=(*args) ⇒ Object 



55198
55199
55200
55201
55202
55203
55204
55205
55206
55207
55208
55209
55210
55211
55212
55213
55214
55215
55216
55217
55218
55219
55220
55221
55222
55223
55224
 
# File 'ext/ctp/ctp.cxx', line 55198

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

#Commission(*args) ⇒ Object 



54637
54638
54639
54640
54641
54642
54643
54644
54645
54646
54647
54648
54649
54650
54651
54652
54653
54654
54655
54656
54657
54658
 
# File 'ext/ctp/ctp.cxx', line 54637

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

#Commission=(*args) ⇒ Object 



54608
54609
54610
54611
54612
54613
54614
54615
54616
54617
54618
54619
54620
54621
54622
54623
54624
54625
54626
54627
54628
54629
54630
54631
54632
54633
54634
 
# File 'ext/ctp/ctp.cxx', line 54608

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

#ExchangeMargin(*args) ⇒ Object 



55068
55069
55070
55071
55072
55073
55074
55075
55076
55077
55078
55079
55080
55081
55082
55083
55084
55085
55086
55087
55088
55089
 
# File 'ext/ctp/ctp.cxx', line 55068

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

#ExchangeMargin=(*args) ⇒ Object 



55039
55040
55041
55042
55043
55044
55045
55046
55047
55048
55049
55050
55051
55052
55053
55054
55055
55056
55057
55058
55059
55060
55061
55062
55063
55064
55065
 
# File 'ext/ctp/ctp.cxx', line 55039

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

#FrozenCash(*args) ⇒ Object 



54478
54479
54480
54481
54482
54483
54484
54485
54486
54487
54488
54489
54490
54491
54492
54493
54494
54495
54496
54497
54498
54499
 
# File 'ext/ctp/ctp.cxx', line 54478

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

#FrozenCash=(*args) ⇒ Object 



54449
54450
54451
54452
54453
54454
54455
54456
54457
54458
54459
54460
54461
54462
54463
54464
54465
54466
54467
54468
54469
54470
54471
54472
54473
54474
54475
 
# File 'ext/ctp/ctp.cxx', line 54449

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

#FrozenCommission(*args) ⇒ Object 



54531
54532
54533
54534
54535
54536
54537
54538
54539
54540
54541
54542
54543
54544
54545
54546
54547
54548
54549
54550
54551
54552
 
# File 'ext/ctp/ctp.cxx', line 54531

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

#FrozenCommission=(*args) ⇒ Object 



54502
54503
54504
54505
54506
54507
54508
54509
54510
54511
54512
54513
54514
54515
54516
54517
54518
54519
54520
54521
54522
54523
54524
54525
54526
54527
54528
 
# File 'ext/ctp/ctp.cxx', line 54502

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

#FrozenMargin(*args) ⇒ Object 



54425
54426
54427
54428
54429
54430
54431
54432
54433
54434
54435
54436
54437
54438
54439
54440
54441
54442
54443
54444
54445
54446
 
# File 'ext/ctp/ctp.cxx', line 54425

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

#FrozenMargin=(*args) ⇒ Object 



54396
54397
54398
54399
54400
54401
54402
54403
54404
54405
54406
54407
54408
54409
54410
54411
54412
54413
54414
54415
54416
54417
54418
54419
54420
54421
54422
 
# File 'ext/ctp/ctp.cxx', line 54396

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

#HedgeFlag(*args) ⇒ Object 



53630
53631
53632
53633
53634
53635
53636
53637
53638
53639
53640
53641
53642
53643
53644
53645
53646
53647
53648
53649
53650
53651
 
# File 'ext/ctp/ctp.cxx', line 53630

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

#HedgeFlag=(*args) ⇒ Object 



53601
53602
53603
53604
53605
53606
53607
53608
53609
53610
53611
53612
53613
53614
53615
53616
53617
53618
53619
53620
53621
53622
53623
53624
53625
53626
53627
 
# File 'ext/ctp/ctp.cxx', line 53601

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



53398
53399
53400
53401
53402
53403
53404
53405
53406
53407
53408
53409
53410
53411
53412
53413
53414
53415
53416
53417
53418
53419
53420
53421
53422
53423
53424
53425
 
# File 'ext/ctp/ctp.cxx', line 53398

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



53368
53369
53370
53371
53372
53373
53374
53375
53376
53377
53378
53379
53380
53381
53382
53383
53384
53385
53386
53387
53388
53389
53390
53391
53392
53393
53394
53395
 
# File 'ext/ctp/ctp.cxx', line 53368

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



53518
53519
53520
53521
53522
53523
53524
53525
53526
53527
53528
53529
53530
53531
53532
53533
53534
53535
53536
53537
53538
53539
53540
53541
53542
53543
53544
53545
 
# File 'ext/ctp/ctp.cxx', line 53518

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



53488
53489
53490
53491
53492
53493
53494
53495
53496
53497
53498
53499
53500
53501
53502
53503
53504
53505
53506
53507
53508
53509
53510
53511
53512
53513
53514
53515
 
# File 'ext/ctp/ctp.cxx', line 53488

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

#LongFrozen(*args) ⇒ Object 



53842
53843
53844
53845
53846
53847
53848
53849
53850
53851
53852
53853
53854
53855
53856
53857
53858
53859
53860
53861
53862
53863
 
# File 'ext/ctp/ctp.cxx', line 53842

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

#LongFrozen=(*args) ⇒ Object 



53813
53814
53815
53816
53817
53818
53819
53820
53821
53822
53823
53824
53825
53826
53827
53828
53829
53830
53831
53832
53833
53834
53835
53836
53837
53838
53839
 
# File 'ext/ctp/ctp.cxx', line 53813

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

#LongFrozenAmount(*args) ⇒ Object 



53948
53949
53950
53951
53952
53953
53954
53955
53956
53957
53958
53959
53960
53961
53962
53963
53964
53965
53966
53967
53968
53969
 
# File 'ext/ctp/ctp.cxx', line 53948

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

#LongFrozenAmount=(*args) ⇒ Object 



53919
53920
53921
53922
53923
53924
53925
53926
53927
53928
53929
53930
53931
53932
53933
53934
53935
53936
53937
53938
53939
53940
53941
53942
53943
53944
53945
 
# File 'ext/ctp/ctp.cxx', line 53919

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

#MarginRateByMoney(*args) ⇒ Object 



55439
55440
55441
55442
55443
55444
55445
55446
55447
55448
55449
55450
55451
55452
55453
55454
55455
55456
55457
55458
55459
55460
 
# File 'ext/ctp/ctp.cxx', line 55439

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

#MarginRateByMoney=(*args) ⇒ Object 



55410
55411
55412
55413
55414
55415
55416
55417
55418
55419
55420
55421
55422
55423
55424
55425
55426
55427
55428
55429
55430
55431
55432
55433
55434
55435
55436
 
# File 'ext/ctp/ctp.cxx', line 55410

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

#MarginRateByVolume(*args) ⇒ Object 



55492
55493
55494
55495
55496
55497
55498
55499
55500
55501
55502
55503
55504
55505
55506
55507
55508
55509
55510
55511
55512
55513
 
# File 'ext/ctp/ctp.cxx', line 55492

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

#MarginRateByVolume=(*args) ⇒ Object 



55463
55464
55465
55466
55467
55468
55469
55470
55471
55472
55473
55474
55475
55476
55477
55478
55479
55480
55481
55482
55483
55484
55485
55486
55487
55488
55489
 
# File 'ext/ctp/ctp.cxx', line 55463

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

#OpenAmount(*args) ⇒ Object 



54160
54161
54162
54163
54164
54165
54166
54167
54168
54169
54170
54171
54172
54173
54174
54175
54176
54177
54178
54179
54180
54181
 
# File 'ext/ctp/ctp.cxx', line 54160

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

#OpenAmount=(*args) ⇒ Object 



54131
54132
54133
54134
54135
54136
54137
54138
54139
54140
54141
54142
54143
54144
54145
54146
54147
54148
54149
54150
54151
54152
54153
54154
54155
54156
54157
 
# File 'ext/ctp/ctp.cxx', line 54131

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

#OpenCost(*args) ⇒ Object 



55015
55016
55017
55018
55019
55020
55021
55022
55023
55024
55025
55026
55027
55028
55029
55030
55031
55032
55033
55034
55035
55036
 
# File 'ext/ctp/ctp.cxx', line 55015

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

#OpenCost=(*args) ⇒ Object 



54986
54987
54988
54989
54990
54991
54992
54993
54994
54995
54996
54997
54998
54999
55000
55001
55002
55003
55004
55005
55006
55007
55008
55009
55010
55011
55012
 
# File 'ext/ctp/ctp.cxx', line 54986

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

#OpenVolume(*args) ⇒ Object 



54054
54055
54056
54057
54058
54059
54060
54061
54062
54063
54064
54065
54066
54067
54068
54069
54070
54071
54072
54073
54074
54075
 
# File 'ext/ctp/ctp.cxx', line 54054

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

#OpenVolume=(*args) ⇒ Object 



54025
54026
54027
54028
54029
54030
54031
54032
54033
54034
54035
54036
54037
54038
54039
54040
54041
54042
54043
54044
54045
54046
54047
54048
54049
54050
54051
 
# File 'ext/ctp/ctp.cxx', line 54025

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

#PosiDirection(*args) ⇒ Object 



53577
53578
53579
53580
53581
53582
53583
53584
53585
53586
53587
53588
53589
53590
53591
53592
53593
53594
53595
53596
53597
53598
 
# File 'ext/ctp/ctp.cxx', line 53577

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

#PosiDirection=(*args) ⇒ Object 



53548
53549
53550
53551
53552
53553
53554
53555
53556
53557
53558
53559
53560
53561
53562
53563
53564
53565
53566
53567
53568
53569
53570
53571
53572
53573
53574
 
# File 'ext/ctp/ctp.cxx', line 53548

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

#Position(*args) ⇒ Object 



53789
53790
53791
53792
53793
53794
53795
53796
53797
53798
53799
53800
53801
53802
53803
53804
53805
53806
53807
53808
53809
53810
 
# File 'ext/ctp/ctp.cxx', line 53789

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

#Position=(*args) ⇒ Object 



53760
53761
53762
53763
53764
53765
53766
53767
53768
53769
53770
53771
53772
53773
53774
53775
53776
53777
53778
53779
53780
53781
53782
53783
53784
53785
53786
 
# File 'ext/ctp/ctp.cxx', line 53760

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

#PositionCost(*args) ⇒ Object 



54266
54267
54268
54269
54270
54271
54272
54273
54274
54275
54276
54277
54278
54279
54280
54281
54282
54283
54284
54285
54286
54287
 
# File 'ext/ctp/ctp.cxx', line 54266

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

#PositionCost=(*args) ⇒ Object 



54237
54238
54239
54240
54241
54242
54243
54244
54245
54246
54247
54248
54249
54250
54251
54252
54253
54254
54255
54256
54257
54258
54259
54260
54261
54262
54263
 
# File 'ext/ctp/ctp.cxx', line 54237

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

#PositionDate(*args) ⇒ Object 



53683
53684
53685
53686
53687
53688
53689
53690
53691
53692
53693
53694
53695
53696
53697
53698
53699
53700
53701
53702
53703
53704
 
# File 'ext/ctp/ctp.cxx', line 53683

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

#PositionDate=(*args) ⇒ Object 



53654
53655
53656
53657
53658
53659
53660
53661
53662
53663
53664
53665
53666
53667
53668
53669
53670
53671
53672
53673
53674
53675
53676
53677
53678
53679
53680
 
# File 'ext/ctp/ctp.cxx', line 53654

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

#PositionProfit(*args) ⇒ Object 



54743
54744
54745
54746
54747
54748
54749
54750
54751
54752
54753
54754
54755
54756
54757
54758
54759
54760
54761
54762
54763
54764
 
# File 'ext/ctp/ctp.cxx', line 54743

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

#PositionProfit=(*args) ⇒ Object 



54714
54715
54716
54717
54718
54719
54720
54721
54722
54723
54724
54725
54726
54727
54728
54729
54730
54731
54732
54733
54734
54735
54736
54737
54738
54739
54740
 
# File 'ext/ctp/ctp.cxx', line 54714

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

#PreMargin(*args) ⇒ Object 



54319
54320
54321
54322
54323
54324
54325
54326
54327
54328
54329
54330
54331
54332
54333
54334
54335
54336
54337
54338
54339
54340
 
# File 'ext/ctp/ctp.cxx', line 54319

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

#PreMargin=(*args) ⇒ Object 



54290
54291
54292
54293
54294
54295
54296
54297
54298
54299
54300
54301
54302
54303
54304
54305
54306
54307
54308
54309
54310
54311
54312
54313
54314
54315
54316
 
# File 'ext/ctp/ctp.cxx', line 54290

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

#PreSettlementPrice(*args) ⇒ Object 



54796
54797
54798
54799
54800
54801
54802
54803
54804
54805
54806
54807
54808
54809
54810
54811
54812
54813
54814
54815
54816
54817
 
# File 'ext/ctp/ctp.cxx', line 54796

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

#PreSettlementPrice=(*args) ⇒ Object 



54767
54768
54769
54770
54771
54772
54773
54774
54775
54776
54777
54778
54779
54780
54781
54782
54783
54784
54785
54786
54787
54788
54789
54790
54791
54792
54793
 
# File 'ext/ctp/ctp.cxx', line 54767

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

#SettlementID(*args) ⇒ Object 



54962
54963
54964
54965
54966
54967
54968
54969
54970
54971
54972
54973
54974
54975
54976
54977
54978
54979
54980
54981
54982
54983
 
# File 'ext/ctp/ctp.cxx', line 54962

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

#SettlementID=(*args) ⇒ Object 



54933
54934
54935
54936
54937
54938
54939
54940
54941
54942
54943
54944
54945
54946
54947
54948
54949
54950
54951
54952
54953
54954
54955
54956
54957
54958
54959
 
# File 'ext/ctp/ctp.cxx', line 54933

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

#SettlementPrice(*args) ⇒ Object 



54849
54850
54851
54852
54853
54854
54855
54856
54857
54858
54859
54860
54861
54862
54863
54864
54865
54866
54867
54868
54869
54870
 
# File 'ext/ctp/ctp.cxx', line 54849

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

#SettlementPrice=(*args) ⇒ Object 



54820
54821
54822
54823
54824
54825
54826
54827
54828
54829
54830
54831
54832
54833
54834
54835
54836
54837
54838
54839
54840
54841
54842
54843
54844
54845
54846
 
# File 'ext/ctp/ctp.cxx', line 54820

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

#ShortFrozen(*args) ⇒ Object 



53895
53896
53897
53898
53899
53900
53901
53902
53903
53904
53905
53906
53907
53908
53909
53910
53911
53912
53913
53914
53915
53916
 
# File 'ext/ctp/ctp.cxx', line 53895

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

#ShortFrozen=(*args) ⇒ Object 



53866
53867
53868
53869
53870
53871
53872
53873
53874
53875
53876
53877
53878
53879
53880
53881
53882
53883
53884
53885
53886
53887
53888
53889
53890
53891
53892
 
# File 'ext/ctp/ctp.cxx', line 53866

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

#ShortFrozenAmount(*args) ⇒ Object 



54001
54002
54003
54004
54005
54006
54007
54008
54009
54010
54011
54012
54013
54014
54015
54016
54017
54018
54019
54020
54021
54022
 
# File 'ext/ctp/ctp.cxx', line 54001

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

#ShortFrozenAmount=(*args) ⇒ Object 



53972
53973
53974
53975
53976
53977
53978
53979
53980
53981
53982
53983
53984
53985
53986
53987
53988
53989
53990
53991
53992
53993
53994
53995
53996
53997
53998
 
# File 'ext/ctp/ctp.cxx', line 53972

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

#StrikeFrozen(*args) ⇒ Object 



55545
55546
55547
55548
55549
55550
55551
55552
55553
55554
55555
55556
55557
55558
55559
55560
55561
55562
55563
55564
55565
55566
 
# File 'ext/ctp/ctp.cxx', line 55545

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

#StrikeFrozen=(*args) ⇒ Object 



55516
55517
55518
55519
55520
55521
55522
55523
55524
55525
55526
55527
55528
55529
55530
55531
55532
55533
55534
55535
55536
55537
55538
55539
55540
55541
55542
 
# File 'ext/ctp/ctp.cxx', line 55516

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

#StrikeFrozenAmount(*args) ⇒ Object 



55598
55599
55600
55601
55602
55603
55604
55605
55606
55607
55608
55609
55610
55611
55612
55613
55614
55615
55616
55617
55618
55619
 
# File 'ext/ctp/ctp.cxx', line 55598

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

#StrikeFrozenAmount=(*args) ⇒ Object 



55569
55570
55571
55572
55573
55574
55575
55576
55577
55578
55579
55580
55581
55582
55583
55584
55585
55586
55587
55588
55589
55590
55591
55592
55593
55594
55595
 
# File 'ext/ctp/ctp.cxx', line 55569

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

#TodayPosition(*args) ⇒ Object 



55386
55387
55388
55389
55390
55391
55392
55393
55394
55395
55396
55397
55398
55399
55400
55401
55402
55403
55404
55405
55406
55407
 
# File 'ext/ctp/ctp.cxx', line 55386

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

#TodayPosition=(*args) ⇒ Object 



55357
55358
55359
55360
55361
55362
55363
55364
55365
55366
55367
55368
55369
55370
55371
55372
55373
55374
55375
55376
55377
55378
55379
55380
55381
55382
55383
 
# File 'ext/ctp/ctp.cxx', line 55357

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

#TradingDay(*args) ⇒ Object 



54903
54904
54905
54906
54907
54908
54909
54910
54911
54912
54913
54914
54915
54916
54917
54918
54919
54920
54921
54922
54923
54924
54925
54926
54927
54928
54929
54930
 
# File 'ext/ctp/ctp.cxx', line 54903

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



54873
54874
54875
54876
54877
54878
54879
54880
54881
54882
54883
54884
54885
54886
54887
54888
54889
54890
54891
54892
54893
54894
54895
54896
54897
54898
54899
54900
 
# File 'ext/ctp/ctp.cxx', line 54873

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

#UseMargin(*args) ⇒ Object 



54372
54373
54374
54375
54376
54377
54378
54379
54380
54381
54382
54383
54384
54385
54386
54387
54388
54389
54390
54391
54392
54393
 
# File 'ext/ctp/ctp.cxx', line 54372

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

#UseMargin=(*args) ⇒ Object 



54343
54344
54345
54346
54347
54348
54349
54350
54351
54352
54353
54354
54355
54356
54357
54358
54359
54360
54361
54362
54363
54364
54365
54366
54367
54368
54369
 
# File 'ext/ctp/ctp.cxx', line 54343

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

#YdPosition(*args) ⇒ Object 



53736
53737
53738
53739
53740
53741
53742
53743
53744
53745
53746
53747
53748
53749
53750
53751
53752
53753
53754
53755
53756
53757
 
# File 'ext/ctp/ctp.cxx', line 53736

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

#YdPosition=(*args) ⇒ Object 



53707
53708
53709
53710
53711
53712
53713
53714
53715
53716
53717
53718
53719
53720
53721
53722
53723
53724
53725
53726
53727
53728
53729
53730
53731
53732
53733
 
# File 'ext/ctp/ctp.cxx', line 53707

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