Class: Ctp::CThostFtdcSyncingInvestorField

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



50235
50236
50237
50238
50239
50240
50241
50242
50243
50244
50245
50246
50247
50248
 
# File 'ext/ctp/ctp.cxx', line 50235

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

Instance Method Details

#Address(*args) ⇒ Object 



49950
49951
49952
49953
49954
49955
49956
49957
49958
49959
49960
49961
49962
49963
49964
49965
49966
49967
49968
49969
49970
49971
49972
49973
49974
49975
49976
49977
 
# File 'ext/ctp/ctp.cxx', line 49950

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

#Address=(*args) ⇒ Object 



49920
49921
49922
49923
49924
49925
49926
49927
49928
49929
49930
49931
49932
49933
49934
49935
49936
49937
49938
49939
49940
49941
49942
49943
49944
49945
49946
49947
 
# File 'ext/ctp/ctp.cxx', line 49920

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

#BrokerID(*args) ⇒ Object 



49544
49545
49546
49547
49548
49549
49550
49551
49552
49553
49554
49555
49556
49557
49558
49559
49560
49561
49562
49563
49564
49565
49566
49567
49568
49569
49570
49571
 
# File 'ext/ctp/ctp.cxx', line 49544

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



49514
49515
49516
49517
49518
49519
49520
49521
49522
49523
49524
49525
49526
49527
49528
49529
49530
49531
49532
49533
49534
49535
49536
49537
49538
49539
49540
49541
 
# File 'ext/ctp/ctp.cxx', line 49514

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

#CommModelID(*args) ⇒ Object 



50130
50131
50132
50133
50134
50135
50136
50137
50138
50139
50140
50141
50142
50143
50144
50145
50146
50147
50148
50149
50150
50151
50152
50153
50154
50155
50156
50157
 
# File 'ext/ctp/ctp.cxx', line 50130

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

#CommModelID=(*args) ⇒ Object 



50100
50101
50102
50103
50104
50105
50106
50107
50108
50109
50110
50111
50112
50113
50114
50115
50116
50117
50118
50119
50120
50121
50122
50123
50124
50125
50126
50127
 
# File 'ext/ctp/ctp.cxx', line 50100

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

#IdentifiedCardNo(*args) ⇒ Object 



49777
49778
49779
49780
49781
49782
49783
49784
49785
49786
49787
49788
49789
49790
49791
49792
49793
49794
49795
49796
49797
49798
49799
49800
49801
49802
49803
49804
 
# File 'ext/ctp/ctp.cxx', line 49777

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

#IdentifiedCardNo=(*args) ⇒ Object 



49747
49748
49749
49750
49751
49752
49753
49754
49755
49756
49757
49758
49759
49760
49761
49762
49763
49764
49765
49766
49767
49768
49769
49770
49771
49772
49773
49774
 
# File 'ext/ctp/ctp.cxx', line 49747

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

#IdentifiedCardType(*args) ⇒ Object 



49723
49724
49725
49726
49727
49728
49729
49730
49731
49732
49733
49734
49735
49736
49737
49738
49739
49740
49741
49742
49743
49744
 
# File 'ext/ctp/ctp.cxx', line 49723

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

#IdentifiedCardType=(*args) ⇒ Object 



49694
49695
49696
49697
49698
49699
49700
49701
49702
49703
49704
49705
49706
49707
49708
49709
49710
49711
49712
49713
49714
49715
49716
49717
49718
49719
49720
 
# File 'ext/ctp/ctp.cxx', line 49694

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

#InvestorGroupID(*args) ⇒ Object 



49604
49605
49606
49607
49608
49609
49610
49611
49612
49613
49614
49615
49616
49617
49618
49619
49620
49621
49622
49623
49624
49625
49626
49627
49628
49629
49630
49631
 
# File 'ext/ctp/ctp.cxx', line 49604

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

#InvestorGroupID=(*args) ⇒ Object 



49574
49575
49576
49577
49578
49579
49580
49581
49582
49583
49584
49585
49586
49587
49588
49589
49590
49591
49592
49593
49594
49595
49596
49597
49598
49599
49600
49601
 
# File 'ext/ctp/ctp.cxx', line 49574

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

#InvestorID(*args) ⇒ Object 



49484
49485
49486
49487
49488
49489
49490
49491
49492
49493
49494
49495
49496
49497
49498
49499
49500
49501
49502
49503
49504
49505
49506
49507
49508
49509
49510
49511
 
# File 'ext/ctp/ctp.cxx', line 49484

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



49454
49455
49456
49457
49458
49459
49460
49461
49462
49463
49464
49465
49466
49467
49468
49469
49470
49471
49472
49473
49474
49475
49476
49477
49478
49479
49480
49481
 
# File 'ext/ctp/ctp.cxx', line 49454

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

#InvestorName(*args) ⇒ Object 



49664
49665
49666
49667
49668
49669
49670
49671
49672
49673
49674
49675
49676
49677
49678
49679
49680
49681
49682
49683
49684
49685
49686
49687
49688
49689
49690
49691
 
# File 'ext/ctp/ctp.cxx', line 49664

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

#InvestorName=(*args) ⇒ Object 



49634
49635
49636
49637
49638
49639
49640
49641
49642
49643
49644
49645
49646
49647
49648
49649
49650
49651
49652
49653
49654
49655
49656
49657
49658
49659
49660
49661
 
# File 'ext/ctp/ctp.cxx', line 49634

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

#IsActive(*args) ⇒ Object 



49836
49837
49838
49839
49840
49841
49842
49843
49844
49845
49846
49847
49848
49849
49850
49851
49852
49853
49854
49855
49856
49857
 
# File 'ext/ctp/ctp.cxx', line 49836

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

#IsActive=(*args) ⇒ Object 



49807
49808
49809
49810
49811
49812
49813
49814
49815
49816
49817
49818
49819
49820
49821
49822
49823
49824
49825
49826
49827
49828
49829
49830
49831
49832
49833
 
# File 'ext/ctp/ctp.cxx', line 49807

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

#MarginModelID(*args) ⇒ Object 



50190
50191
50192
50193
50194
50195
50196
50197
50198
50199
50200
50201
50202
50203
50204
50205
50206
50207
50208
50209
50210
50211
50212
50213
50214
50215
50216
50217
 
# File 'ext/ctp/ctp.cxx', line 50190

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

#MarginModelID=(*args) ⇒ Object 



50160
50161
50162
50163
50164
50165
50166
50167
50168
50169
50170
50171
50172
50173
50174
50175
50176
50177
50178
50179
50180
50181
50182
50183
50184
50185
50186
50187
 
# File 'ext/ctp/ctp.cxx', line 50160

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

#Mobile(*args) ⇒ Object 



50070
50071
50072
50073
50074
50075
50076
50077
50078
50079
50080
50081
50082
50083
50084
50085
50086
50087
50088
50089
50090
50091
50092
50093
50094
50095
50096
50097
 
# File 'ext/ctp/ctp.cxx', line 50070

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

#Mobile=(*args) ⇒ Object 



50040
50041
50042
50043
50044
50045
50046
50047
50048
50049
50050
50051
50052
50053
50054
50055
50056
50057
50058
50059
50060
50061
50062
50063
50064
50065
50066
50067
 
# File 'ext/ctp/ctp.cxx', line 50040

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

#OpenDate(*args) ⇒ Object 



50010
50011
50012
50013
50014
50015
50016
50017
50018
50019
50020
50021
50022
50023
50024
50025
50026
50027
50028
50029
50030
50031
50032
50033
50034
50035
50036
50037
 
# File 'ext/ctp/ctp.cxx', line 50010

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

#OpenDate=(*args) ⇒ Object 



49980
49981
49982
49983
49984
49985
49986
49987
49988
49989
49990
49991
49992
49993
49994
49995
49996
49997
49998
49999
50000
50001
50002
50003
50004
50005
50006
50007
 
# File 'ext/ctp/ctp.cxx', line 49980

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

#Telephone(*args) ⇒ Object 



49890
49891
49892
49893
49894
49895
49896
49897
49898
49899
49900
49901
49902
49903
49904
49905
49906
49907
49908
49909
49910
49911
49912
49913
49914
49915
49916
49917
 
# File 'ext/ctp/ctp.cxx', line 49890

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

#Telephone=(*args) ⇒ Object 



49860
49861
49862
49863
49864
49865
49866
49867
49868
49869
49870
49871
49872
49873
49874
49875
49876
49877
49878
49879
49880
49881
49882
49883
49884
49885
49886
49887
 
# File 'ext/ctp/ctp.cxx', line 49860

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