Class: Ctp::CThostFtdcExchangeTradeField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



45404
45405
45406
45407
45408
45409
45410
45411
45412
45413
45414
45415
45416
45417
 
# File 'ext/ctp/ctp.cxx', line 45404

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

Instance Method Details

#BusinessUnit(*args) ⇒ Object 



45253
45254
45255
45256
45257
45258
45259
45260
45261
45262
45263
45264
45265
45266
45267
45268
45269
45270
45271
45272
45273
45274
45275
45276
45277
45278
45279
45280
 
# File 'ext/ctp/ctp.cxx', line 45253

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

#BusinessUnit=(*args) ⇒ Object 



45223
45224
45225
45226
45227
45228
45229
45230
45231
45232
45233
45234
45235
45236
45237
45238
45239
45240
45241
45242
45243
45244
45245
45246
45247
45248
45249
45250
 
# File 'ext/ctp/ctp.cxx', line 45223

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

#ClearingPartID(*args) ⇒ Object 



45193
45194
45195
45196
45197
45198
45199
45200
45201
45202
45203
45204
45205
45206
45207
45208
45209
45210
45211
45212
45213
45214
45215
45216
45217
45218
45219
45220
 
# File 'ext/ctp/ctp.cxx', line 45193

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

#ClearingPartID=(*args) ⇒ Object 



45163
45164
45165
45166
45167
45168
45169
45170
45171
45172
45173
45174
45175
45176
45177
45178
45179
45180
45181
45182
45183
45184
45185
45186
45187
45188
45189
45190
 
# File 'ext/ctp/ctp.cxx', line 45163

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

#ClientID(*args) ⇒ Object 



44462
44463
44464
44465
44466
44467
44468
44469
44470
44471
44472
44473
44474
44475
44476
44477
44478
44479
44480
44481
44482
44483
44484
44485
44486
44487
44488
44489
 
# File 'ext/ctp/ctp.cxx', line 44462

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

#ClientID=(*args) ⇒ Object 



44432
44433
44434
44435
44436
44437
44438
44439
44440
44441
44442
44443
44444
44445
44446
44447
44448
44449
44450
44451
44452
44453
44454
44455
44456
44457
44458
44459
 
# File 'ext/ctp/ctp.cxx', line 44432

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

#Direction(*args) ⇒ Object 



44288
44289
44290
44291
44292
44293
44294
44295
44296
44297
44298
44299
44300
44301
44302
44303
44304
44305
44306
44307
44308
44309
 
# File 'ext/ctp/ctp.cxx', line 44288

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

#Direction=(*args) ⇒ Object 



44259
44260
44261
44262
44263
44264
44265
44266
44267
44268
44269
44270
44271
44272
44273
44274
44275
44276
44277
44278
44279
44280
44281
44282
44283
44284
44285
 
# File 'ext/ctp/ctp.cxx', line 44259

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

#ExchangeID(*args) ⇒ Object 



44169
44170
44171
44172
44173
44174
44175
44176
44177
44178
44179
44180
44181
44182
44183
44184
44185
44186
44187
44188
44189
44190
44191
44192
44193
44194
44195
44196
 
# File 'ext/ctp/ctp.cxx', line 44169

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

#ExchangeID=(*args) ⇒ Object 



44139
44140
44141
44142
44143
44144
44145
44146
44147
44148
44149
44150
44151
44152
44153
44154
44155
44156
44157
44158
44159
44160
44161
44162
44163
44164
44165
44166
 
# File 'ext/ctp/ctp.cxx', line 44139

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

#ExchangeInstID(*args) ⇒ Object 



44575
44576
44577
44578
44579
44580
44581
44582
44583
44584
44585
44586
44587
44588
44589
44590
44591
44592
44593
44594
44595
44596
44597
44598
44599
44600
44601
44602
 
# File 'ext/ctp/ctp.cxx', line 44575

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

#ExchangeInstID=(*args) ⇒ Object 



44545
44546
44547
44548
44549
44550
44551
44552
44553
44554
44555
44556
44557
44558
44559
44560
44561
44562
44563
44564
44565
44566
44567
44568
44569
44570
44571
44572
 
# File 'ext/ctp/ctp.cxx', line 44545

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

#HedgeFlag(*args) ⇒ Object 



44687
44688
44689
44690
44691
44692
44693
44694
44695
44696
44697
44698
44699
44700
44701
44702
44703
44704
44705
44706
44707
44708
 
# File 'ext/ctp/ctp.cxx', line 44687

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

#HedgeFlag=(*args) ⇒ Object 



44658
44659
44660
44661
44662
44663
44664
44665
44666
44667
44668
44669
44670
44671
44672
44673
44674
44675
44676
44677
44678
44679
44680
44681
44682
44683
44684
 
# File 'ext/ctp/ctp.cxx', line 44658

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

#OffsetFlag(*args) ⇒ Object 



44634
44635
44636
44637
44638
44639
44640
44641
44642
44643
44644
44645
44646
44647
44648
44649
44650
44651
44652
44653
44654
44655
 
# File 'ext/ctp/ctp.cxx', line 44634

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

#OffsetFlag=(*args) ⇒ Object 



44605
44606
44607
44608
44609
44610
44611
44612
44613
44614
44615
44616
44617
44618
44619
44620
44621
44622
44623
44624
44625
44626
44627
44628
44629
44630
44631
 
# File 'ext/ctp/ctp.cxx', line 44605

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

#OrderLocalID(*args) ⇒ Object 



45133
45134
45135
45136
45137
45138
45139
45140
45141
45142
45143
45144
45145
45146
45147
45148
45149
45150
45151
45152
45153
45154
45155
45156
45157
45158
45159
45160
 
# File 'ext/ctp/ctp.cxx', line 45133

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

#OrderLocalID=(*args) ⇒ Object 



45103
45104
45105
45106
45107
45108
45109
45110
45111
45112
45113
45114
45115
45116
45117
45118
45119
45120
45121
45122
45123
45124
45125
45126
45127
45128
45129
45130
 
# File 'ext/ctp/ctp.cxx', line 45103

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

#OrderSysID(*args) ⇒ Object 



44342
44343
44344
44345
44346
44347
44348
44349
44350
44351
44352
44353
44354
44355
44356
44357
44358
44359
44360
44361
44362
44363
44364
44365
44366
44367
44368
44369
 
# File 'ext/ctp/ctp.cxx', line 44342

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

#OrderSysID=(*args) ⇒ Object 



44312
44313
44314
44315
44316
44317
44318
44319
44320
44321
44322
44323
44324
44325
44326
44327
44328
44329
44330
44331
44332
44333
44334
44335
44336
44337
44338
44339
 
# File 'ext/ctp/ctp.cxx', line 44312

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

#ParticipantID(*args) ⇒ Object 



44402
44403
44404
44405
44406
44407
44408
44409
44410
44411
44412
44413
44414
44415
44416
44417
44418
44419
44420
44421
44422
44423
44424
44425
44426
44427
44428
44429
 
# File 'ext/ctp/ctp.cxx', line 44402

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

#ParticipantID=(*args) ⇒ Object 



44372
44373
44374
44375
44376
44377
44378
44379
44380
44381
44382
44383
44384
44385
44386
44387
44388
44389
44390
44391
44392
44393
44394
44395
44396
44397
44398
44399
 
# File 'ext/ctp/ctp.cxx', line 44372

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

#Price(*args) ⇒ Object 



44740
44741
44742
44743
44744
44745
44746
44747
44748
44749
44750
44751
44752
44753
44754
44755
44756
44757
44758
44759
44760
44761
 
# File 'ext/ctp/ctp.cxx', line 44740

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

#Price=(*args) ⇒ Object 



44711
44712
44713
44714
44715
44716
44717
44718
44719
44720
44721
44722
44723
44724
44725
44726
44727
44728
44729
44730
44731
44732
44733
44734
44735
44736
44737
 
# File 'ext/ctp/ctp.cxx', line 44711

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

#PriceSource(*args) ⇒ Object 



45019
45020
45021
45022
45023
45024
45025
45026
45027
45028
45029
45030
45031
45032
45033
45034
45035
45036
45037
45038
45039
45040
 
# File 'ext/ctp/ctp.cxx', line 45019

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

#PriceSource=(*args) ⇒ Object 



44990
44991
44992
44993
44994
44995
44996
44997
44998
44999
45000
45001
45002
45003
45004
45005
45006
45007
45008
45009
45010
45011
45012
45013
45014
45015
45016
 
# File 'ext/ctp/ctp.cxx', line 44990

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

#SequenceNo(*args) ⇒ Object 



45312
45313
45314
45315
45316
45317
45318
45319
45320
45321
45322
45323
45324
45325
45326
45327
45328
45329
45330
45331
45332
45333
 
# File 'ext/ctp/ctp.cxx', line 45312

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

#SequenceNo=(*args) ⇒ Object 



45283
45284
45285
45286
45287
45288
45289
45290
45291
45292
45293
45294
45295
45296
45297
45298
45299
45300
45301
45302
45303
45304
45305
45306
45307
45308
45309
 
# File 'ext/ctp/ctp.cxx', line 45283

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

#TradeDate(*args) ⇒ Object 



44847
44848
44849
44850
44851
44852
44853
44854
44855
44856
44857
44858
44859
44860
44861
44862
44863
44864
44865
44866
44867
44868
44869
44870
44871
44872
44873
44874
 
# File 'ext/ctp/ctp.cxx', line 44847

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

#TradeDate=(*args) ⇒ Object 



44817
44818
44819
44820
44821
44822
44823
44824
44825
44826
44827
44828
44829
44830
44831
44832
44833
44834
44835
44836
44837
44838
44839
44840
44841
44842
44843
44844
 
# File 'ext/ctp/ctp.cxx', line 44817

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

#TradeID(*args) ⇒ Object 



44229
44230
44231
44232
44233
44234
44235
44236
44237
44238
44239
44240
44241
44242
44243
44244
44245
44246
44247
44248
44249
44250
44251
44252
44253
44254
44255
44256
 
# File 'ext/ctp/ctp.cxx', line 44229

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

#TradeID=(*args) ⇒ Object 



44199
44200
44201
44202
44203
44204
44205
44206
44207
44208
44209
44210
44211
44212
44213
44214
44215
44216
44217
44218
44219
44220
44221
44222
44223
44224
44225
44226
 
# File 'ext/ctp/ctp.cxx', line 44199

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

#TraderID(*args) ⇒ Object 



45073
45074
45075
45076
45077
45078
45079
45080
45081
45082
45083
45084
45085
45086
45087
45088
45089
45090
45091
45092
45093
45094
45095
45096
45097
45098
45099
45100
 
# File 'ext/ctp/ctp.cxx', line 45073

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

#TraderID=(*args) ⇒ Object 



45043
45044
45045
45046
45047
45048
45049
45050
45051
45052
45053
45054
45055
45056
45057
45058
45059
45060
45061
45062
45063
45064
45065
45066
45067
45068
45069
45070
 
# File 'ext/ctp/ctp.cxx', line 45043

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

#TradeSource(*args) ⇒ Object 



45365
45366
45367
45368
45369
45370
45371
45372
45373
45374
45375
45376
45377
45378
45379
45380
45381
45382
45383
45384
45385
45386
 
# File 'ext/ctp/ctp.cxx', line 45365

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

#TradeSource=(*args) ⇒ Object 



45336
45337
45338
45339
45340
45341
45342
45343
45344
45345
45346
45347
45348
45349
45350
45351
45352
45353
45354
45355
45356
45357
45358
45359
45360
45361
45362
 
# File 'ext/ctp/ctp.cxx', line 45336

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

#TradeTime(*args) ⇒ Object 



44907
44908
44909
44910
44911
44912
44913
44914
44915
44916
44917
44918
44919
44920
44921
44922
44923
44924
44925
44926
44927
44928
44929
44930
44931
44932
44933
44934
 
# File 'ext/ctp/ctp.cxx', line 44907

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

#TradeTime=(*args) ⇒ Object 



44877
44878
44879
44880
44881
44882
44883
44884
44885
44886
44887
44888
44889
44890
44891
44892
44893
44894
44895
44896
44897
44898
44899
44900
44901
44902
44903
44904
 
# File 'ext/ctp/ctp.cxx', line 44877

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

#TradeType(*args) ⇒ Object 



44966
44967
44968
44969
44970
44971
44972
44973
44974
44975
44976
44977
44978
44979
44980
44981
44982
44983
44984
44985
44986
44987
 
# File 'ext/ctp/ctp.cxx', line 44966

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

#TradeType=(*args) ⇒ Object 



44937
44938
44939
44940
44941
44942
44943
44944
44945
44946
44947
44948
44949
44950
44951
44952
44953
44954
44955
44956
44957
44958
44959
44960
44961
44962
44963
 
# File 'ext/ctp/ctp.cxx', line 44937

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

#TradingRole(*args) ⇒ Object 



44521
44522
44523
44524
44525
44526
44527
44528
44529
44530
44531
44532
44533
44534
44535
44536
44537
44538
44539
44540
44541
44542
 
# File 'ext/ctp/ctp.cxx', line 44521

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

#TradingRole=(*args) ⇒ Object 



44492
44493
44494
44495
44496
44497
44498
44499
44500
44501
44502
44503
44504
44505
44506
44507
44508
44509
44510
44511
44512
44513
44514
44515
44516
44517
44518
 
# File 'ext/ctp/ctp.cxx', line 44492

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

#Volume(*args) ⇒ Object 



44793
44794
44795
44796
44797
44798
44799
44800
44801
44802
44803
44804
44805
44806
44807
44808
44809
44810
44811
44812
44813
44814
 
# File 'ext/ctp/ctp.cxx', line 44793

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

#Volume=(*args) ⇒ Object 



44764
44765
44766
44767
44768
44769
44770
44771
44772
44773
44774
44775
44776
44777
44778
44779
44780
44781
44782
44783
44784
44785
44786
44787
44788
44789
44790
 
# File 'ext/ctp/ctp.cxx', line 44764

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