Class: Ctp::CThostFtdcOrderField

Inherits:

Object

Object
Ctp::CThostFtdcOrderField

Defined in:: ext/ctp/ctp.cxx

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37490

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

Instance Method Details

#ActiveTime(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36534

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

#ActiveTime=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36504

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

#ActiveTraderID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36774

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

#ActiveTraderID=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36744

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

#ActiveUserID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37226

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

#ActiveUserID=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37196

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

#BrokerID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34281

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

# File 'ext/ctp/ctp.cxx', line 34251

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

#BrokerOrderSeq(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37285

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

#BrokerOrderSeq=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37256

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

#BusinessUnit(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35344

SWIGINTERN VALUE
_wrap_CThostFtdcOrderField_BusinessUnit_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcOrderField *arg1 = (CThostFtdcOrderField *) 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_CThostFtdcOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcOrderField *","BusinessUnit", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcOrderField * >(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`

# File 'ext/ctp/ctp.cxx', line 35314

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

#CancelTime(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36714

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

#CancelTime=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36684

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

#ClearingPartID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36834

SWIGINTERN VALUE
_wrap_CThostFtdcOrderField_ClearingPartID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcOrderField *arg1 = (CThostFtdcOrderField *) 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_CThostFtdcOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcOrderField *","ClearingPartID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcOrderField * >(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`

# File 'ext/ctp/ctp.cxx', line 36804

SWIGINTERN VALUE
_wrap_CThostFtdcOrderField_ClearingPartID_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcOrderField *arg1 = (CThostFtdcOrderField *) 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_CThostFtdcOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcOrderField *","ClearingPartID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcOrderField * >(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`

# File 'ext/ctp/ctp.cxx', line 35637

SWIGINTERN VALUE
_wrap_CThostFtdcOrderField_ClientID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcOrderField *arg1 = (CThostFtdcOrderField *) 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_CThostFtdcOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcOrderField *","ClientID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcOrderField * >(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`

# File 'ext/ctp/ctp.cxx', line 35607

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

#CombHedgeFlag(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34747

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

#CombHedgeFlag=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34717

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

#CombOffsetFlag(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34687

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

#CombOffsetFlag=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34657

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

#ContingentCondition(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35131

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

#ContingentCondition=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35102

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

#Direction(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34633

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

#Direction=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34604

SWIGINTERN VALUE
_wrap_CThostFtdcOrderField_Direction_set(int argc, VALUE *argv, VALUE self) {
  CThostFtdcOrderField *arg1 = (CThostFtdcOrderField *) 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_CThostFtdcOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcOrderField *","Direction", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcOrderField * >(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`

# File 'ext/ctp/ctp.cxx', line 35517

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

# File 'ext/ctp/ctp.cxx', line 35487

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

# File 'ext/ctp/ctp.cxx', line 35697

SWIGINTERN VALUE
_wrap_CThostFtdcOrderField_ExchangeInstID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcOrderField *arg1 = (CThostFtdcOrderField *) 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_CThostFtdcOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcOrderField *","ExchangeInstID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcOrderField * >(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`

# File 'ext/ctp/ctp.cxx', line 35667

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

#ForceCloseReason(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35237

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

#ForceCloseReason=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35208

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

#FrontID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36946

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

#FrontID=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36917

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

#GTDDate(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34966

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

#GTDDate=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34936

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

#InsertDate(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36414

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

#InsertDate=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36384

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

#InsertTime(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36474

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

#InsertTime=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36444

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

#InstallID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35816

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

#InstallID=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35787

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

#InstrumentID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34401

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

# File 'ext/ctp/ctp.cxx', line 34371

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

# File 'ext/ctp/ctp.cxx', line 34341

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

# File 'ext/ctp/ctp.cxx', line 34311

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

#IsAutoSuspend(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35290

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

#IsAutoSuspend=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35261

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

#IsSwapOrder(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37451

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

#IsSwapOrder=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37422

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

#LimitPrice(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34806

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

#LimitPrice=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34777

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

#MinVolume(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35078

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

#MinVolume=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35049

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

#NotifySequence(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35922

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

#NotifySequence=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35893

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

#OrderLocalID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35457

SWIGINTERN VALUE
_wrap_CThostFtdcOrderField_OrderLocalID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcOrderField *arg1 = (CThostFtdcOrderField *) 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_CThostFtdcOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcOrderField *","OrderLocalID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcOrderField * >(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`

# File 'ext/ctp/ctp.cxx', line 35427

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

#OrderPriceType(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34580

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

#OrderPriceType=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34551

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

#OrderRef(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34461

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

#OrderRef=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34431

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

#OrderSource(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36148

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

#OrderSource=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36119

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

#OrderStatus(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36201

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

#OrderStatus=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36172

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

#OrderSubmitStatus(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35869

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

#OrderSubmitStatus=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35840

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

#OrderSysID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36089

SWIGINTERN VALUE
_wrap_CThostFtdcOrderField_OrderSysID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcOrderField *arg1 = (CThostFtdcOrderField *) 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_CThostFtdcOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcOrderField *","OrderSysID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcOrderField * >(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`

# File 'ext/ctp/ctp.cxx', line 36059

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

#OrderType(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36254

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

#OrderType=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36225

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

#ParticipantID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35577

SWIGINTERN VALUE
_wrap_CThostFtdcOrderField_ParticipantID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcOrderField *arg1 = (CThostFtdcOrderField *) 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_CThostFtdcOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcOrderField *","ParticipantID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcOrderField * >(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`

# File 'ext/ctp/ctp.cxx', line 35547

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

#RelativeOrderSysID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37339

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

#RelativeOrderSysID=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37309

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

#RequestID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35403

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

#RequestID=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35374

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

#SequenceNo(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36893

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

#SequenceNo=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36864

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

#SessionID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36999

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

#SessionID=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36970

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

#SettlementID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36035

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

#SettlementID=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36006

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

#StatusMsg(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37113

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

#StatusMsg=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37083

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

#StopPrice(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35184

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

#StopPrice=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35155

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

#SuspendTime(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36594

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

#SuspendTime=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36564

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

#TimeCondition(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34912

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

#TimeCondition=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34883

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

#TraderID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35757

SWIGINTERN VALUE
_wrap_CThostFtdcOrderField_TraderID_get(int argc, VALUE *argv, VALUE self) {
  CThostFtdcOrderField *arg1 = (CThostFtdcOrderField *) 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_CThostFtdcOrderField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CThostFtdcOrderField *","TraderID", 1, self )); 
  }
  arg1 = reinterpret_cast< CThostFtdcOrderField * >(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`

# File 'ext/ctp/ctp.cxx', line 35727

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

#TradingDay(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35976

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

# File 'ext/ctp/ctp.cxx', line 35946

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

#UpdateTime(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36654

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

#UpdateTime=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36624

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

#UserForceClose(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37172

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

#UserForceClose=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37143

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

#UserID(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34521

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

#UserID=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34491

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

#UserProductInfo(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37053

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

#UserProductInfo=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37023

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

#VolumeCondition(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 35025

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

#VolumeCondition=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34996

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

#VolumeTotal(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36360

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

#VolumeTotal=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36331

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

#VolumeTotalOriginal(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34859

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

#VolumeTotalOriginal=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 34830

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

#VolumeTraded(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36307

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

#VolumeTraded=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 36278

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

#ZCETotalTradedVolume(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37398

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

#ZCETotalTradedVolume=(*args) ⇒ `Object`

# File 'ext/ctp/ctp.cxx', line 37369

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

Class: Ctp::CThostFtdcOrderField

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

Instance Method Details

#ActiveTime(*args) ⇒ Object

#ActiveTime=(*args) ⇒ Object

#ActiveTraderID(*args) ⇒ Object

#ActiveTraderID=(*args) ⇒ Object

#ActiveUserID(*args) ⇒ Object

#ActiveUserID=(*args) ⇒ Object

#BrokerID(*args) ⇒ Object

#BrokerID=(*args) ⇒ Object

#BrokerOrderSeq(*args) ⇒ Object

#BrokerOrderSeq=(*args) ⇒ Object

#BusinessUnit(*args) ⇒ Object

#BusinessUnit=(*args) ⇒ Object

#CancelTime(*args) ⇒ Object

#CancelTime=(*args) ⇒ Object

#ClearingPartID(*args) ⇒ Object

#ClearingPartID=(*args) ⇒ Object

#ClientID(*args) ⇒ Object

#ClientID=(*args) ⇒ Object

#CombHedgeFlag(*args) ⇒ Object

#CombHedgeFlag=(*args) ⇒ Object

#CombOffsetFlag(*args) ⇒ Object

#CombOffsetFlag=(*args) ⇒ Object

#ContingentCondition(*args) ⇒ Object

#ContingentCondition=(*args) ⇒ Object

#Direction(*args) ⇒ Object

#Direction=(*args) ⇒ Object

#ExchangeID(*args) ⇒ Object

#ExchangeID=(*args) ⇒ Object

#ExchangeInstID(*args) ⇒ Object

#ExchangeInstID=(*args) ⇒ Object

#ForceCloseReason(*args) ⇒ Object

#ForceCloseReason=(*args) ⇒ Object

#FrontID(*args) ⇒ Object

#FrontID=(*args) ⇒ Object

#GTDDate(*args) ⇒ Object

#GTDDate=(*args) ⇒ Object

#InsertDate(*args) ⇒ Object

#InsertDate=(*args) ⇒ Object

#InsertTime(*args) ⇒ Object

#InsertTime=(*args) ⇒ Object

#InstallID(*args) ⇒ Object

#InstallID=(*args) ⇒ Object

#InstrumentID(*args) ⇒ Object

#InstrumentID=(*args) ⇒ Object

#InvestorID(*args) ⇒ Object

#InvestorID=(*args) ⇒ Object

#IsAutoSuspend(*args) ⇒ Object

#IsAutoSuspend=(*args) ⇒ Object

#IsSwapOrder(*args) ⇒ Object

#IsSwapOrder=(*args) ⇒ Object

#LimitPrice(*args) ⇒ Object

#LimitPrice=(*args) ⇒ Object

#MinVolume(*args) ⇒ Object

#MinVolume=(*args) ⇒ Object

#NotifySequence(*args) ⇒ Object

#NotifySequence=(*args) ⇒ Object

#OrderLocalID(*args) ⇒ Object

#OrderLocalID=(*args) ⇒ Object

#OrderPriceType(*args) ⇒ Object

#OrderPriceType=(*args) ⇒ Object

#OrderRef(*args) ⇒ Object

#OrderRef=(*args) ⇒ Object

#OrderSource(*args) ⇒ Object

#OrderSource=(*args) ⇒ Object

#OrderStatus(*args) ⇒ Object

#OrderStatus=(*args) ⇒ Object

#OrderSubmitStatus(*args) ⇒ Object

#OrderSubmitStatus=(*args) ⇒ Object

#OrderSysID(*args) ⇒ Object

#OrderSysID=(*args) ⇒ Object

#OrderType(*args) ⇒ Object

#OrderType=(*args) ⇒ Object

#ParticipantID(*args) ⇒ Object

#ParticipantID=(*args) ⇒ Object

#RelativeOrderSysID(*args) ⇒ Object

#initialize(*args) ⇒ `Object`

#ActiveTime(*args) ⇒ `Object`

#ActiveTime=(*args) ⇒ `Object`

#ActiveTraderID(*args) ⇒ `Object`

#ActiveTraderID=(*args) ⇒ `Object`

#ActiveUserID(*args) ⇒ `Object`

#ActiveUserID=(*args) ⇒ `Object`

#BrokerID(*args) ⇒ `Object`

#BrokerID=(*args) ⇒ `Object`

#BrokerOrderSeq(*args) ⇒ `Object`

#BrokerOrderSeq=(*args) ⇒ `Object`

#BusinessUnit(*args) ⇒ `Object`

#BusinessUnit=(*args) ⇒ `Object`

#CancelTime(*args) ⇒ `Object`

#CancelTime=(*args) ⇒ `Object`

#ClearingPartID(*args) ⇒ `Object`

#ClearingPartID=(*args) ⇒ `Object`

#ClientID(*args) ⇒ `Object`

#ClientID=(*args) ⇒ `Object`

#CombHedgeFlag(*args) ⇒ `Object`

#CombHedgeFlag=(*args) ⇒ `Object`

#CombOffsetFlag(*args) ⇒ `Object`

#CombOffsetFlag=(*args) ⇒ `Object`

#ContingentCondition(*args) ⇒ `Object`

#ContingentCondition=(*args) ⇒ `Object`

#Direction(*args) ⇒ `Object`

#Direction=(*args) ⇒ `Object`

#ExchangeID(*args) ⇒ `Object`

#ExchangeID=(*args) ⇒ `Object`

#ExchangeInstID(*args) ⇒ `Object`

#ExchangeInstID=(*args) ⇒ `Object`

#ForceCloseReason(*args) ⇒ `Object`

#ForceCloseReason=(*args) ⇒ `Object`

#FrontID(*args) ⇒ `Object`

#FrontID=(*args) ⇒ `Object`

#GTDDate(*args) ⇒ `Object`

#GTDDate=(*args) ⇒ `Object`

#InsertDate(*args) ⇒ `Object`

#InsertDate=(*args) ⇒ `Object`

#InsertTime(*args) ⇒ `Object`

#InsertTime=(*args) ⇒ `Object`

#InstallID(*args) ⇒ `Object`

#InstallID=(*args) ⇒ `Object`

#InstrumentID(*args) ⇒ `Object`

#InstrumentID=(*args) ⇒ `Object`

#InvestorID(*args) ⇒ `Object`

#InvestorID=(*args) ⇒ `Object`

#IsAutoSuspend(*args) ⇒ `Object`

#IsAutoSuspend=(*args) ⇒ `Object`

#IsSwapOrder(*args) ⇒ `Object`

#IsSwapOrder=(*args) ⇒ `Object`

#LimitPrice(*args) ⇒ `Object`

#LimitPrice=(*args) ⇒ `Object`

#MinVolume(*args) ⇒ `Object`

#MinVolume=(*args) ⇒ `Object`

#NotifySequence(*args) ⇒ `Object`

#NotifySequence=(*args) ⇒ `Object`

#OrderLocalID(*args) ⇒ `Object`

#OrderLocalID=(*args) ⇒ `Object`

#OrderPriceType(*args) ⇒ `Object`

#OrderPriceType=(*args) ⇒ `Object`

#OrderRef(*args) ⇒ `Object`

#OrderRef=(*args) ⇒ `Object`

#OrderSource(*args) ⇒ `Object`

#OrderSource=(*args) ⇒ `Object`

#OrderStatus(*args) ⇒ `Object`

#OrderStatus=(*args) ⇒ `Object`

#OrderSubmitStatus(*args) ⇒ `Object`

#OrderSubmitStatus=(*args) ⇒ `Object`

#OrderSysID(*args) ⇒ `Object`

#OrderSysID=(*args) ⇒ `Object`

#OrderType(*args) ⇒ `Object`

#OrderType=(*args) ⇒ `Object`

#ParticipantID(*args) ⇒ `Object`

#ParticipantID=(*args) ⇒ `Object`

#RelativeOrderSysID(*args) ⇒ `Object`

#RelativeOrderSysID=(*args) ⇒ `Object`

#RequestID(*args) ⇒ `Object`

#RequestID=(*args) ⇒ `Object`

#SequenceNo(*args) ⇒ `Object`