Class: Quickfix::DataDictionary
- Inherits:
-
Object
- Object
- Quickfix::DataDictionary
- Defined in:
- lib/quickfix_ruby.rb,
ext/quickfix/QuickfixRuby.cpp
Instance Method Summary collapse
- #_getFieldName(*args) ⇒ Object
- #_getFieldTag(*args) ⇒ Object
- #_getGroup(*args) ⇒ Object
- #_getValueName(*args) ⇒ Object
- #addField(*args) ⇒ Object
- #addFieldName(*args) ⇒ Object
- #addFieldType(*args) ⇒ Object
- #addFieldValue(*args) ⇒ Object
- #addGroup(*args) ⇒ Object
- #addHeaderField(*args) ⇒ Object
- #addMsgField(*args) ⇒ Object
- #addMsgType(*args) ⇒ Object
- #addRequiredField(*args) ⇒ Object
- #addTrailerField(*args) ⇒ Object
- #addValueName(*args) ⇒ Object
- #allowUnknownMsgFields(*args) ⇒ Object
- #checkFieldsHaveValues(*args) ⇒ Object
- #checkFieldsOutOfOrder(*args) ⇒ Object
- #checkUserDefinedFields(*args) ⇒ Object
- #getFieldName(field) ⇒ Object
- #getFieldTag(field) ⇒ Object
- #getFieldType(*args) ⇒ Object
- #getGroup(msgType, group) ⇒ Object
- #getHeaderOrderedFields(*args) ⇒ Object
- #getMessageOrderedFields(*args) ⇒ Object
- #getOrderedFields(*args) ⇒ Object
- #getTrailerOrderedFields(*args) ⇒ Object
- #getValueName(field, value) ⇒ Object
- #getVersion(*args) ⇒ Object
- #hasFieldValue(*args) ⇒ Object
- #initialize(*args, self) ⇒ Object constructor
- #isDataField(*args) ⇒ Object
- #isField(*args) ⇒ Object
- #isFieldValue(*args) ⇒ Object
- #isGroup(*args) ⇒ Object
- #isHeaderField(*args) ⇒ Object
- #isMessageFieldsOrderPreserved(*args) ⇒ Object
- #isMsgField(*args) ⇒ Object
- #isMsgType(*args) ⇒ Object
- #isMultipleValueField(*args) ⇒ Object
- #isRequiredField(*args) ⇒ Object
- #isTrailerField(*args) ⇒ Object
- #preserveMessageFieldsOrder(*args) ⇒ Object
- #readFromDocument(*args) ⇒ Object
- #readFromStream(*args) ⇒ Object
- #readFromURL(*args) ⇒ Object
- #setVersion(*args) ⇒ Object
- #validate(*args, self) ⇒ Object
Constructor Details
#initialize(*args, self) ⇒ Object
218189 218190 218191 218192 218193 218194 218195 218196 218197 218198 218199 218200 218201 218202 218203 218204 218205 218206 218207 218208 218209 218210 218211 218212 218213 218214 218215 218216 218217 218218 218219 218220 218221 218222 218223 218224 218225 218226 218227 218228 218229 218230 218231 218232 218233 218234 218235 218236 218237 218238 218239 218240 218241 218242 218243 218244 218245 218246 218247 218248 218249 218250 218251 218252 218253 218254 218255 218256 218257 218258 218259 218260 218261 218262 218263 218264 218265 218266 218267 218268 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218189
SWIGINTERN VALUE _wrap_new_DataDictionary(int nargs, VALUE *args, VALUE self) {
int argc;
VALUE argv[2];
int ii;
argc = nargs;
if (argc > 2) SWIG_fail;
for (ii = 0; (ii < argc); ++ii) {
argv[ii] = args[ii];
}
if (argc == 0) {
return _wrap_new_DataDictionary__SWIG_0(nargs, args, self);
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_DataDictionary__SWIG_1(nargs, args, self);
}
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_DataDictionary__SWIG_3(nargs, args, self);
}
}
if (argc == 1) {
int _v;
int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_DataDictionary__SWIG_5(nargs, args, self);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_bool(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_DataDictionary__SWIG_2(nargs, args, self);
}
}
}
if (argc == 2) {
int _v;
int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_bool(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_DataDictionary__SWIG_4(nargs, args, self);
}
}
}
fail:
Ruby_Format_OverloadedError( argc, 2, "DataDictionary.new",
" DataDictionary.new()\n"
" DataDictionary.new(FIX::DataDictionary const ©)\n"
" DataDictionary.new(std::istream &stream, bool preserveMsgFldsOrder)\n"
" DataDictionary.new(std::istream &stream)\n"
" DataDictionary.new(std::string const &url, bool preserveMsgFldsOrder)\n"
" DataDictionary.new(std::string const &url)\n");
return Qnil;
}
|
Instance Method Details
#_getFieldName(*args) ⇒ Object
218688 218689 218690 218691 218692 218693 218694 218695 218696 218697 218698 218699 218700 218701 218702 218703 218704 218705 218706 218707 218708 218709 218710 218711 218712 218713 218714 218715 218716 218717 218718 218719 218720 218721 218722 218723 218724 218725 218726 218727 218728 218729 218730 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218688
SWIGINTERN VALUE
_wrap_DataDictionary__getFieldName(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
std::string *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
std::string temp3 ;
bool result;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getFieldName", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getFieldName", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
{
temp3 = std::string((char*)StringValuePtr(argv[1]));
arg3 = &temp3;
}
result = (bool)((FIX::DataDictionary const *)arg1)->getFieldName(arg2,*arg3);
vresult = SWIG_From_bool(static_cast< bool >(result));
{
if( std::string("std::string &") == "std::string &" )
{
rb_str_resize( argv[1], 0 );
rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
}
}
return vresult;
fail:
return Qnil;
}
|
#_getFieldTag(*args) ⇒ Object
218733 218734 218735 218736 218737 218738 218739 218740 218741 218742 218743 218744 218745 218746 218747 218748 218749 218750 218751 218752 218753 218754 218755 218756 218757 218758 218759 218760 218761 218762 218763 218764 218765 218766 218767 218768 218769 218770 218771 218772 218773 218774 218775 218776 218777 218778 218779 218780 218781 218782 218783 218784 218785 218786 218787 218788 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218733
SWIGINTERN VALUE
_wrap_DataDictionary__getFieldTag(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
int *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
int temp3 ;
bool result;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getFieldTag", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","getFieldTag", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getFieldTag", 2, argv[0]));
}
arg2 = ptr;
}
{
temp3 = NUM2INT(argv[1]);
arg3 = &temp3;
}
result = (bool)((FIX::DataDictionary const *)arg1)->getFieldTag((std::string const &)*arg2,*arg3);
vresult = SWIG_From_bool(static_cast< bool >(result));
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
{
if( std::string("int &") == "int &" )
{
vresult = result ? SWIG_From_int(static_cast< int >(*arg3)) : Qnil;
}
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#_getGroup(*args) ⇒ Object
219754 219755 219756 219757 219758 219759 219760 219761 219762 219763 219764 219765 219766 219767 219768 219769 219770 219771 219772 219773 219774 219775 219776 219777 219778 219779 219780 219781 219782 219783 219784 219785 219786 219787 219788 219789 219790 219791 219792 219793 219794 219795 219796 219797 219798 219799 219800 219801 219802 219803 219804 219805 219806 219807 219808 219809 219810 219811 219812 219813 219814 219815 219816 219817 219818 219819 219820 219821 219822 219823 219824 219825 219826 219827 219828 219829 219830 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219754
SWIGINTERN VALUE
_wrap_DataDictionary__getGroup(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
int arg3 ;
int *arg4 = 0 ;
FIX::DataDictionary **arg5 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
int val3 ;
int ecode3 = 0 ;
int temp4 ;
FIX::DataDictionary *temp5 ;
bool result;
VALUE vresult = Qnil;
if ((argc < 4) || (argc > 4)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getGroup", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","getGroup", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getGroup", 2, argv[0]));
}
arg2 = ptr;
}
ecode3 = SWIG_AsVal_int(argv[1], &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","getGroup", 3, argv[1] ));
}
arg3 = static_cast< int >(val3);
{
temp4 = NUM2INT(argv[2]);
arg4 = &temp4;
}
{
arg5 = new FIX::DataDictionary*[1];
*arg5 = temp5;
}
result = (bool)((FIX::DataDictionary const *)arg1)->getGroup((std::string const &)*arg2,arg3,*arg4,(FIX::DataDictionary const *&)*arg5);
vresult = SWIG_From_bool(static_cast< bool >(result));
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
{
if( std::string("int &") == "int &" )
{
vresult = result ? SWIG_From_int(static_cast< int >(*arg4)) : Qnil;
}
}
{
void* argp;
FIX::DataDictionary* pDD = 0;
int res = SWIG_ConvertPtr(argv[3], &argp, SWIGTYPE_p_FIX__DataDictionary, 0 );
pDD = reinterpret_cast< FIX::DataDictionary * >(argp);
*pDD = *(*arg5);
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#_getValueName(*args) ⇒ Object
218866 218867 218868 218869 218870 218871 218872 218873 218874 218875 218876 218877 218878 218879 218880 218881 218882 218883 218884 218885 218886 218887 218888 218889 218890 218891 218892 218893 218894 218895 218896 218897 218898 218899 218900 218901 218902 218903 218904 218905 218906 218907 218908 218909 218910 218911 218912 218913 218914 218915 218916 218917 218918 218919 218920 218921 218922 218923 218924 218925 218926 218927 218928 218929 218930 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218866
SWIGINTERN VALUE
_wrap_DataDictionary__getValueName(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
std::string *arg3 = 0 ;
std::string *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int res3 = SWIG_OLDOBJ ;
std::string temp4 ;
bool result;
VALUE vresult = Qnil;
if ((argc < 3) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getValueName", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getValueName", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
{
std::string *ptr = (std::string *)0;
res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","getValueName", 3, argv[1] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getValueName", 3, argv[1]));
}
arg3 = ptr;
}
{
temp4 = std::string((char*)StringValuePtr(argv[2]));
arg4 = &temp4;
}
result = (bool)((FIX::DataDictionary const *)arg1)->getValueName(arg2,(std::string const &)*arg3,*arg4);
vresult = SWIG_From_bool(static_cast< bool >(result));
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[1], 0 );
rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
}
}
{
if( std::string("std::string &") == "std::string &" )
{
rb_str_resize( argv[2], 0 );
rb_str_append( argv[2], rb_str_new2(arg4->c_str()) );
}
}
if (SWIG_IsNewObj(res3)) delete arg3;
return vresult;
fail:
if (SWIG_IsNewObj(res3)) delete arg3;
return Qnil;
}
|
#addField(*args) ⇒ Object
218607 218608 218609 218610 218611 218612 218613 218614 218615 218616 218617 218618 218619 218620 218621 218622 218623 218624 218625 218626 218627 218628 218629 218630 218631 218632 218633 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218607
SWIGINTERN VALUE
_wrap_DataDictionary_addField(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int 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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addField", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addField", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
(arg1)->addField(arg2);
return Qnil;
fail:
return Qnil;
}
|
#addFieldName(*args) ⇒ Object
218636 218637 218638 218639 218640 218641 218642 218643 218644 218645 218646 218647 218648 218649 218650 218651 218652 218653 218654 218655 218656 218657 218658 218659 218660 218661 218662 218663 218664 218665 218666 218667 218668 218669 218670 218671 218672 218673 218674 218675 218676 218677 218678 218679 218680 218681 218682 218683 218684 218685 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218636
SWIGINTERN VALUE
_wrap_DataDictionary_addFieldName(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
std::string *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int res3 = SWIG_OLDOBJ ;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addFieldName", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addFieldName", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
{
std::string *ptr = (std::string *)0;
res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","addFieldName", 3, argv[1] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addFieldName", 3, argv[1]));
}
arg3 = ptr;
}
(arg1)->addFieldName(arg2,(std::string const &)*arg3);
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[1], 0 );
rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
}
}
if (SWIG_IsNewObj(res3)) delete arg3;
return vresult;
fail:
if (SWIG_IsNewObj(res3)) delete arg3;
return Qnil;
}
|
#addFieldType(*args) ⇒ Object
219299 219300 219301 219302 219303 219304 219305 219306 219307 219308 219309 219310 219311 219312 219313 219314 219315 219316 219317 219318 219319 219320 219321 219322 219323 219324 219325 219326 219327 219328 219329 219330 219331 219332 219333 219334 219335 219336 219337 219338 219339 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219299
SWIGINTERN VALUE
_wrap_DataDictionary_addFieldType(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
FIX::TYPE::Type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 ;
int res3 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addFieldType", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addFieldType", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
{
res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__TYPE__Type, 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::TYPE::Type","addFieldType", 3, argv[1] ));
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::TYPE::Type","addFieldType", 3, argv[1]));
} else {
arg3 = *(reinterpret_cast< FIX::TYPE::Type * >(argp3));
}
}
(arg1)->addFieldType(arg2,arg3);
return Qnil;
fail:
return Qnil;
}
|
#addFieldValue(*args) ⇒ Object
219491 219492 219493 219494 219495 219496 219497 219498 219499 219500 219501 219502 219503 219504 219505 219506 219507 219508 219509 219510 219511 219512 219513 219514 219515 219516 219517 219518 219519 219520 219521 219522 219523 219524 219525 219526 219527 219528 219529 219530 219531 219532 219533 219534 219535 219536 219537 219538 219539 219540 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219491
SWIGINTERN VALUE
_wrap_DataDictionary_addFieldValue(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
std::string *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int res3 = SWIG_OLDOBJ ;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addFieldValue", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addFieldValue", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
{
std::string *ptr = (std::string *)0;
res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","addFieldValue", 3, argv[1] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addFieldValue", 3, argv[1]));
}
arg3 = ptr;
}
(arg1)->addFieldValue(arg2,(std::string const &)*arg3);
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[1], 0 );
rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
}
}
if (SWIG_IsNewObj(res3)) delete arg3;
return vresult;
fail:
if (SWIG_IsNewObj(res3)) delete arg3;
return Qnil;
}
|
#addGroup(*args) ⇒ Object
219629 219630 219631 219632 219633 219634 219635 219636 219637 219638 219639 219640 219641 219642 219643 219644 219645 219646 219647 219648 219649 219650 219651 219652 219653 219654 219655 219656 219657 219658 219659 219660 219661 219662 219663 219664 219665 219666 219667 219668 219669 219670 219671 219672 219673 219674 219675 219676 219677 219678 219679 219680 219681 219682 219683 219684 219685 219686 219687 219688 219689 219690 219691 219692 219693 219694 219695 219696 219697 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219629
SWIGINTERN VALUE
_wrap_DataDictionary_addGroup(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
int arg3 ;
int arg4 ;
FIX::DataDictionary *arg5 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 ;
int res5 = 0 ;
VALUE vresult = Qnil;
if ((argc < 4) || (argc > 4)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addGroup", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","addGroup", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addGroup", 2, argv[0]));
}
arg2 = ptr;
}
ecode3 = SWIG_AsVal_int(argv[1], &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","addGroup", 3, argv[1] ));
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(argv[2], &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","addGroup", 4, argv[2] ));
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_FIX__DataDictionary, 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FIX::DataDictionary const &","addGroup", 5, argv[3] ));
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::DataDictionary const &","addGroup", 5, argv[3]));
}
arg5 = reinterpret_cast< FIX::DataDictionary * >(argp5);
(arg1)->addGroup((std::string const &)*arg2,arg3,arg4,(FIX::DataDictionary const &)*arg5);
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#addHeaderField(*args) ⇒ Object
219161 219162 219163 219164 219165 219166 219167 219168 219169 219170 219171 219172 219173 219174 219175 219176 219177 219178 219179 219180 219181 219182 219183 219184 219185 219186 219187 219188 219189 219190 219191 219192 219193 219194 219195 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219161
SWIGINTERN VALUE
_wrap_DataDictionary_addHeaderField(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
bool arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
bool val3 ;
int ecode3 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addHeaderField", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addHeaderField", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_bool(argv[1], &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","addHeaderField", 3, argv[1] ));
}
arg3 = static_cast< bool >(val3);
(arg1)->addHeaderField(arg2,arg3);
return Qnil;
fail:
return Qnil;
}
|
#addMsgField(*args) ⇒ Object
219055 219056 219057 219058 219059 219060 219061 219062 219063 219064 219065 219066 219067 219068 219069 219070 219071 219072 219073 219074 219075 219076 219077 219078 219079 219080 219081 219082 219083 219084 219085 219086 219087 219088 219089 219090 219091 219092 219093 219094 219095 219096 219097 219098 219099 219100 219101 219102 219103 219104 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219055
SWIGINTERN VALUE
_wrap_DataDictionary_addMsgField(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
int val3 ;
int ecode3 = 0 ;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addMsgField", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","addMsgField", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addMsgField", 2, argv[0]));
}
arg2 = ptr;
}
ecode3 = SWIG_AsVal_int(argv[1], &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","addMsgField", 3, argv[1] ));
}
arg3 = static_cast< int >(val3);
(arg1)->addMsgField((std::string const &)*arg2,arg3);
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#addMsgType(*args) ⇒ Object
218965 218966 218967 218968 218969 218970 218971 218972 218973 218974 218975 218976 218977 218978 218979 218980 218981 218982 218983 218984 218985 218986 218987 218988 218989 218990 218991 218992 218993 218994 218995 218996 218997 218998 218999 219000 219001 219002 219003 219004 219005 219006 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218965
SWIGINTERN VALUE
_wrap_DataDictionary_addMsgType(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
VALUE vresult = Qnil;
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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addMsgType", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","addMsgType", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addMsgType", 2, argv[0]));
}
arg2 = ptr;
}
(arg1)->addMsgType((std::string const &)*arg2);
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#addRequiredField(*args) ⇒ Object
219385 219386 219387 219388 219389 219390 219391 219392 219393 219394 219395 219396 219397 219398 219399 219400 219401 219402 219403 219404 219405 219406 219407 219408 219409 219410 219411 219412 219413 219414 219415 219416 219417 219418 219419 219420 219421 219422 219423 219424 219425 219426 219427 219428 219429 219430 219431 219432 219433 219434 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219385
SWIGINTERN VALUE
_wrap_DataDictionary_addRequiredField(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
int val3 ;
int ecode3 = 0 ;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addRequiredField", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","addRequiredField", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addRequiredField", 2, argv[0]));
}
arg2 = ptr;
}
ecode3 = SWIG_AsVal_int(argv[1], &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","addRequiredField", 3, argv[1] ));
}
arg3 = static_cast< int >(val3);
(arg1)->addRequiredField((std::string const &)*arg2,arg3);
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#addTrailerField(*args) ⇒ Object
219230 219231 219232 219233 219234 219235 219236 219237 219238 219239 219240 219241 219242 219243 219244 219245 219246 219247 219248 219249 219250 219251 219252 219253 219254 219255 219256 219257 219258 219259 219260 219261 219262 219263 219264 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219230
SWIGINTERN VALUE
_wrap_DataDictionary_addTrailerField(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
bool arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
bool val3 ;
int ecode3 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addTrailerField", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addTrailerField", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_bool(argv[1], &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","addTrailerField", 3, argv[1] ));
}
arg3 = static_cast< bool >(val3);
(arg1)->addTrailerField(arg2,arg3);
return Qnil;
fail:
return Qnil;
}
|
#addValueName(*args) ⇒ Object
218791 218792 218793 218794 218795 218796 218797 218798 218799 218800 218801 218802 218803 218804 218805 218806 218807 218808 218809 218810 218811 218812 218813 218814 218815 218816 218817 218818 218819 218820 218821 218822 218823 218824 218825 218826 218827 218828 218829 218830 218831 218832 218833 218834 218835 218836 218837 218838 218839 218840 218841 218842 218843 218844 218845 218846 218847 218848 218849 218850 218851 218852 218853 218854 218855 218856 218857 218858 218859 218860 218861 218862 218863 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218791
SWIGINTERN VALUE
_wrap_DataDictionary_addValueName(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
std::string *arg3 = 0 ;
std::string *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int res3 = SWIG_OLDOBJ ;
int res4 = SWIG_OLDOBJ ;
VALUE vresult = Qnil;
if ((argc < 3) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","addValueName", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addValueName", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
{
std::string *ptr = (std::string *)0;
res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","addValueName", 3, argv[1] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addValueName", 3, argv[1]));
}
arg3 = ptr;
}
{
std::string *ptr = (std::string *)0;
res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::string const &","addValueName", 4, argv[2] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addValueName", 4, argv[2]));
}
arg4 = ptr;
}
(arg1)->addValueName(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
vresult = rb_ary_new();
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[1], 0 );
rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
}
}
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[2], 0 );
rb_str_append( argv[2], rb_str_new2(arg4->c_str()) );
}
}
if (SWIG_IsNewObj(res3)) delete arg3;
if (SWIG_IsNewObj(res4)) delete arg4;
return vresult;
fail:
if (SWIG_IsNewObj(res3)) delete arg3;
if (SWIG_IsNewObj(res4)) delete arg4;
return Qnil;
}
|
#allowUnknownMsgFields(*args) ⇒ Object
219984 219985 219986 219987 219988 219989 219990 219991 219992 219993 219994 219995 219996 219997 219998 219999 220000 220001 220002 220003 220004 220005 220006 220007 220008 220009 220010 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219984
SWIGINTERN VALUE
_wrap_DataDictionary_allowUnknownMsgFields(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
bool arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool 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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","allowUnknownMsgFields", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_bool(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","allowUnknownMsgFields", 2, argv[0] ));
}
arg2 = static_cast< bool >(val2);
(arg1)->allowUnknownMsgFields(arg2);
return Qnil;
fail:
return Qnil;
}
|
#checkFieldsHaveValues(*args) ⇒ Object
219926 219927 219928 219929 219930 219931 219932 219933 219934 219935 219936 219937 219938 219939 219940 219941 219942 219943 219944 219945 219946 219947 219948 219949 219950 219951 219952 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219926
SWIGINTERN VALUE
_wrap_DataDictionary_checkFieldsHaveValues(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
bool arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool 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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","checkFieldsHaveValues", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_bool(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","checkFieldsHaveValues", 2, argv[0] ));
}
arg2 = static_cast< bool >(val2);
(arg1)->checkFieldsHaveValues(arg2);
return Qnil;
fail:
return Qnil;
}
|
#checkFieldsOutOfOrder(*args) ⇒ Object
219897 219898 219899 219900 219901 219902 219903 219904 219905 219906 219907 219908 219909 219910 219911 219912 219913 219914 219915 219916 219917 219918 219919 219920 219921 219922 219923 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219897
SWIGINTERN VALUE
_wrap_DataDictionary_checkFieldsOutOfOrder(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
bool arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool 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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","checkFieldsOutOfOrder", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_bool(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","checkFieldsOutOfOrder", 2, argv[0] ));
}
arg2 = static_cast< bool >(val2);
(arg1)->checkFieldsOutOfOrder(arg2);
return Qnil;
fail:
return Qnil;
}
|
#checkUserDefinedFields(*args) ⇒ Object
219955 219956 219957 219958 219959 219960 219961 219962 219963 219964 219965 219966 219967 219968 219969 219970 219971 219972 219973 219974 219975 219976 219977 219978 219979 219980 219981 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219955
SWIGINTERN VALUE
_wrap_DataDictionary_checkUserDefinedFields(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
bool arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool 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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","checkUserDefinedFields", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_bool(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","checkUserDefinedFields", 2, argv[0] ));
}
arg2 = static_cast< bool >(val2);
(arg1)->checkUserDefinedFields(arg2);
return Qnil;
fail:
return Qnil;
}
|
#getFieldName(field) ⇒ Object
11 12 13 14 15 16 17 18 |
# File 'lib/quickfix_ruby.rb', line 11 def getFieldName( field ) name = String.new if( _getFieldName(field, name) ) return name else return nil end end |
#getFieldTag(field) ⇒ Object
29 30 31 32 |
# File 'lib/quickfix_ruby.rb', line 29 def getFieldTag( field ) tag = 0 return _getFieldTag(field, tag) end |
#getFieldType(*args) ⇒ Object
219342 219343 219344 219345 219346 219347 219348 219349 219350 219351 219352 219353 219354 219355 219356 219357 219358 219359 219360 219361 219362 219363 219364 219365 219366 219367 219368 219369 219370 219371 219372 219373 219374 219375 219376 219377 219378 219379 219380 219381 219382 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219342
SWIGINTERN VALUE
_wrap_DataDictionary_getFieldType(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
FIX::TYPE::Type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
bool result;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getFieldType", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getFieldType", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__TYPE__Type, 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::TYPE::Type &","getFieldType", 3, argv[1] ));
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::TYPE::Type &","getFieldType", 3, argv[1]));
}
arg3 = reinterpret_cast< FIX::TYPE::Type * >(argp3);
result = (bool)((FIX::DataDictionary const *)arg1)->getFieldType(arg2,*arg3);
vresult = SWIG_From_bool(static_cast< bool >(result));
return vresult;
fail:
return Qnil;
}
|
#getGroup(msgType, group) ⇒ Object
34 35 36 37 38 39 40 |
# File 'lib/quickfix_ruby.rb', line 34 def getGroup( msgType, group ) delim = 0 dictionary = Quickfix::DataDictionary.new delim = _getGroup( msgType, group, delim, dictionary ) return nil if delim == nil return [delim, dictionary] end |
#getHeaderOrderedFields(*args) ⇒ Object
218427 218428 218429 218430 218431 218432 218433 218434 218435 218436 218437 218438 218439 218440 218441 218442 218443 218444 218445 218446 218447 218448 218449 218450 218451 218452 218453 218454 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218427
SWIGINTERN VALUE
_wrap_DataDictionary_getHeaderOrderedFields(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
message_order *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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getHeaderOrderedFields", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
try {
result = (message_order *) &((FIX::DataDictionary const *)arg1)->getHeaderOrderedFields();
}
catch(FIX::ConfigError &_e) {
rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
}
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_message_order, 0 | 0 );
return vresult;
fail:
return Qnil;
}
|
#getMessageOrderedFields(*args) ⇒ Object
218487 218488 218489 218490 218491 218492 218493 218494 218495 218496 218497 218498 218499 218500 218501 218502 218503 218504 218505 218506 218507 218508 218509 218510 218511 218512 218513 218514 218515 218516 218517 218518 218519 218520 218521 218522 218523 218524 218525 218526 218527 218528 218529 218530 218531 218532 218533 218534 218535 218536 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218487
SWIGINTERN VALUE
_wrap_DataDictionary_getMessageOrderedFields(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
message_order *result = 0 ;
VALUE vresult = Qnil;
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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getMessageOrderedFields", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","getMessageOrderedFields", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getMessageOrderedFields", 2, argv[0]));
}
arg2 = ptr;
}
try {
result = (message_order *) &((FIX::DataDictionary const *)arg1)->getMessageOrderedFields((std::string const &)*arg2);
}
catch(FIX::ConfigError &_e) {
rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
}
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_message_order, 0 | 0 );
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#getOrderedFields(*args) ⇒ Object
218403 218404 218405 218406 218407 218408 218409 218410 218411 218412 218413 218414 218415 218416 218417 218418 218419 218420 218421 218422 218423 218424 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218403
SWIGINTERN VALUE
_wrap_DataDictionary_getOrderedFields(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
message_order *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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getOrderedFields", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
result = (message_order *) &((FIX::DataDictionary const *)arg1)->getOrderedFields();
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_message_order, 0 | 0 );
return vresult;
fail:
return Qnil;
}
|
#getTrailerOrderedFields(*args) ⇒ Object
218457 218458 218459 218460 218461 218462 218463 218464 218465 218466 218467 218468 218469 218470 218471 218472 218473 218474 218475 218476 218477 218478 218479 218480 218481 218482 218483 218484 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218457
SWIGINTERN VALUE
_wrap_DataDictionary_getTrailerOrderedFields(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
message_order *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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getTrailerOrderedFields", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
try {
result = (message_order *) &((FIX::DataDictionary const *)arg1)->getTrailerOrderedFields();
}
catch(FIX::ConfigError &_e) {
rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
}
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_message_order, 0 | 0 );
return vresult;
fail:
return Qnil;
}
|
#getValueName(field, value) ⇒ Object
20 21 22 23 24 25 26 27 |
# File 'lib/quickfix_ruby.rb', line 20 def getValueName( field, value ) name = String.new if( _getValueName(field, value, name) ) return name else return nil end end |
#getVersion(*args) ⇒ Object
218583 218584 218585 218586 218587 218588 218589 218590 218591 218592 218593 218594 218595 218596 218597 218598 218599 218600 218601 218602 218603 218604 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218583
SWIGINTERN VALUE
_wrap_DataDictionary_getVersion(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::string 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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","getVersion", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
result = ((FIX::DataDictionary const *)arg1)->getVersion();
vresult = SWIG_From_std_string(static_cast< std::string >(result));
return vresult;
fail:
return Qnil;
}
|
#hasFieldValue(*args) ⇒ Object
219543 219544 219545 219546 219547 219548 219549 219550 219551 219552 219553 219554 219555 219556 219557 219558 219559 219560 219561 219562 219563 219564 219565 219566 219567 219568 219569 219570 219571 219572 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219543
SWIGINTERN VALUE
_wrap_DataDictionary_hasFieldValue(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
bool result;
VALUE vresult = Qnil;
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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","hasFieldValue", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","hasFieldValue", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
result = (bool)((FIX::DataDictionary const *)arg1)->hasFieldValue(arg2);
vresult = SWIG_From_bool(static_cast< bool >(result));
return vresult;
fail:
return Qnil;
}
|
#isDataField(*args) ⇒ Object
219833 219834 219835 219836 219837 219838 219839 219840 219841 219842 219843 219844 219845 219846 219847 219848 219849 219850 219851 219852 219853 219854 219855 219856 219857 219858 219859 219860 219861 219862 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219833
SWIGINTERN VALUE
_wrap_DataDictionary_isDataField(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
bool result;
VALUE vresult = Qnil;
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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isDataField", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isDataField", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
result = (bool)((FIX::DataDictionary const *)arg1)->isDataField(arg2);
vresult = SWIG_From_bool(static_cast< bool >(result));
return vresult;
fail:
return Qnil;
}
|
#isField(*args) ⇒ Object
218933 218934 218935 218936 218937 218938 218939 218940 218941 218942 218943 218944 218945 218946 218947 218948 218949 218950 218951 218952 218953 218954 218955 218956 218957 218958 218959 218960 218961 218962 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218933
SWIGINTERN VALUE
_wrap_DataDictionary_isField(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
bool result;
VALUE vresult = Qnil;
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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isField", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isField", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
result = (bool)((FIX::DataDictionary const *)arg1)->isField(arg2);
vresult = SWIG_From_bool(static_cast< bool >(result));
return vresult;
fail:
return Qnil;
}
|
#isFieldValue(*args) ⇒ Object
219575 219576 219577 219578 219579 219580 219581 219582 219583 219584 219585 219586 219587 219588 219589 219590 219591 219592 219593 219594 219595 219596 219597 219598 219599 219600 219601 219602 219603 219604 219605 219606 219607 219608 219609 219610 219611 219612 219613 219614 219615 219616 219617 219618 219619 219620 219621 219622 219623 219624 219625 219626 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219575
SWIGINTERN VALUE
_wrap_DataDictionary_isFieldValue(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
std::string *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int res3 = SWIG_OLDOBJ ;
bool result;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isFieldValue", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isFieldValue", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
{
std::string *ptr = (std::string *)0;
res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","isFieldValue", 3, argv[1] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","isFieldValue", 3, argv[1]));
}
arg3 = ptr;
}
result = (bool)((FIX::DataDictionary const *)arg1)->isFieldValue(arg2,(std::string const &)*arg3);
vresult = SWIG_From_bool(static_cast< bool >(result));
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[1], 0 );
rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
}
}
if (SWIG_IsNewObj(res3)) delete arg3;
return vresult;
fail:
if (SWIG_IsNewObj(res3)) delete arg3;
return Qnil;
}
|
#isGroup(*args) ⇒ Object
219700 219701 219702 219703 219704 219705 219706 219707 219708 219709 219710 219711 219712 219713 219714 219715 219716 219717 219718 219719 219720 219721 219722 219723 219724 219725 219726 219727 219728 219729 219730 219731 219732 219733 219734 219735 219736 219737 219738 219739 219740 219741 219742 219743 219744 219745 219746 219747 219748 219749 219750 219751 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219700
SWIGINTERN VALUE
_wrap_DataDictionary_isGroup(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
int val3 ;
int ecode3 = 0 ;
bool result;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isGroup", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","isGroup", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","isGroup", 2, argv[0]));
}
arg2 = ptr;
}
ecode3 = SWIG_AsVal_int(argv[1], &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","isGroup", 3, argv[1] ));
}
arg3 = static_cast< int >(val3);
result = (bool)((FIX::DataDictionary const *)arg1)->isGroup((std::string const &)*arg2,arg3);
vresult = SWIG_From_bool(static_cast< bool >(result));
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#isHeaderField(*args) ⇒ Object
219198 219199 219200 219201 219202 219203 219204 219205 219206 219207 219208 219209 219210 219211 219212 219213 219214 219215 219216 219217 219218 219219 219220 219221 219222 219223 219224 219225 219226 219227 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219198
SWIGINTERN VALUE
_wrap_DataDictionary_isHeaderField(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
bool result;
VALUE vresult = Qnil;
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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isHeaderField", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isHeaderField", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
result = (bool)((FIX::DataDictionary const *)arg1)->isHeaderField(arg2);
vresult = SWIG_From_bool(static_cast< bool >(result));
return vresult;
fail:
return Qnil;
}
|
#isMessageFieldsOrderPreserved(*args) ⇒ Object
220042 220043 220044 220045 220046 220047 220048 220049 220050 220051 220052 220053 220054 220055 220056 220057 220058 220059 220060 220061 220062 220063 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 220042
SWIGINTERN VALUE
_wrap_DataDictionary_isMessageFieldsOrderPreserved(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool 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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isMessageFieldsOrderPreserved", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
result = (bool)((FIX::DataDictionary const *)arg1)->isMessageFieldsOrderPreserved();
vresult = SWIG_From_bool(static_cast< bool >(result));
return vresult;
fail:
return Qnil;
}
|
#isMsgField(*args) ⇒ Object
219107 219108 219109 219110 219111 219112 219113 219114 219115 219116 219117 219118 219119 219120 219121 219122 219123 219124 219125 219126 219127 219128 219129 219130 219131 219132 219133 219134 219135 219136 219137 219138 219139 219140 219141 219142 219143 219144 219145 219146 219147 219148 219149 219150 219151 219152 219153 219154 219155 219156 219157 219158 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219107
SWIGINTERN VALUE
_wrap_DataDictionary_isMsgField(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
int val3 ;
int ecode3 = 0 ;
bool result;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isMsgField", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","isMsgField", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","isMsgField", 2, argv[0]));
}
arg2 = ptr;
}
ecode3 = SWIG_AsVal_int(argv[1], &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","isMsgField", 3, argv[1] ));
}
arg3 = static_cast< int >(val3);
result = (bool)((FIX::DataDictionary const *)arg1)->isMsgField((std::string const &)*arg2,arg3);
vresult = SWIG_From_bool(static_cast< bool >(result));
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#isMsgType(*args) ⇒ Object
219009 219010 219011 219012 219013 219014 219015 219016 219017 219018 219019 219020 219021 219022 219023 219024 219025 219026 219027 219028 219029 219030 219031 219032 219033 219034 219035 219036 219037 219038 219039 219040 219041 219042 219043 219044 219045 219046 219047 219048 219049 219050 219051 219052 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219009
SWIGINTERN VALUE
_wrap_DataDictionary_isMsgType(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
bool result;
VALUE vresult = Qnil;
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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isMsgType", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","isMsgType", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","isMsgType", 2, argv[0]));
}
arg2 = ptr;
}
result = (bool)((FIX::DataDictionary const *)arg1)->isMsgType((std::string const &)*arg2);
vresult = SWIG_From_bool(static_cast< bool >(result));
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#isMultipleValueField(*args) ⇒ Object
219865 219866 219867 219868 219869 219870 219871 219872 219873 219874 219875 219876 219877 219878 219879 219880 219881 219882 219883 219884 219885 219886 219887 219888 219889 219890 219891 219892 219893 219894 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219865
SWIGINTERN VALUE
_wrap_DataDictionary_isMultipleValueField(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
bool result;
VALUE vresult = Qnil;
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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isMultipleValueField", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isMultipleValueField", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
result = (bool)((FIX::DataDictionary const *)arg1)->isMultipleValueField(arg2);
vresult = SWIG_From_bool(static_cast< bool >(result));
return vresult;
fail:
return Qnil;
}
|
#isRequiredField(*args) ⇒ Object
219437 219438 219439 219440 219441 219442 219443 219444 219445 219446 219447 219448 219449 219450 219451 219452 219453 219454 219455 219456 219457 219458 219459 219460 219461 219462 219463 219464 219465 219466 219467 219468 219469 219470 219471 219472 219473 219474 219475 219476 219477 219478 219479 219480 219481 219482 219483 219484 219485 219486 219487 219488 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219437
SWIGINTERN VALUE
_wrap_DataDictionary_isRequiredField(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
int val3 ;
int ecode3 = 0 ;
bool result;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isRequiredField", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","isRequiredField", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","isRequiredField", 2, argv[0]));
}
arg2 = ptr;
}
ecode3 = SWIG_AsVal_int(argv[1], &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","isRequiredField", 3, argv[1] ));
}
arg3 = static_cast< int >(val3);
result = (bool)((FIX::DataDictionary const *)arg1)->isRequiredField((std::string const &)*arg2,arg3);
vresult = SWIG_From_bool(static_cast< bool >(result));
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#isTrailerField(*args) ⇒ Object
219267 219268 219269 219270 219271 219272 219273 219274 219275 219276 219277 219278 219279 219280 219281 219282 219283 219284 219285 219286 219287 219288 219289 219290 219291 219292 219293 219294 219295 219296 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 219267
SWIGINTERN VALUE
_wrap_DataDictionary_isTrailerField(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
bool result;
VALUE vresult = Qnil;
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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary const *","isTrailerField", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","isTrailerField", 2, argv[0] ));
}
arg2 = static_cast< int >(val2);
result = (bool)((FIX::DataDictionary const *)arg1)->isTrailerField(arg2);
vresult = SWIG_From_bool(static_cast< bool >(result));
return vresult;
fail:
return Qnil;
}
|
#preserveMessageFieldsOrder(*args) ⇒ Object
220013 220014 220015 220016 220017 220018 220019 220020 220021 220022 220023 220024 220025 220026 220027 220028 220029 220030 220031 220032 220033 220034 220035 220036 220037 220038 220039 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 220013
SWIGINTERN VALUE
_wrap_DataDictionary_preserveMessageFieldsOrder(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
bool arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool 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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","preserveMessageFieldsOrder", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
ecode2 = SWIG_AsVal_bool(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","preserveMessageFieldsOrder", 2, argv[0] ));
}
arg2 = static_cast< bool >(val2);
(arg1)->preserveMessageFieldsOrder(arg2);
return Qnil;
fail:
return Qnil;
}
|
#readFromDocument(*args) ⇒ Object
218327 218328 218329 218330 218331 218332 218333 218334 218335 218336 218337 218338 218339 218340 218341 218342 218343 218344 218345 218346 218347 218348 218349 218350 218351 218352 218353 218354 218355 218356 218357 218358 218359 218360 218361 218362 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218327
SWIGINTERN VALUE
_wrap_DataDictionary_readFromDocument(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
DOMDocumentPtr *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","readFromDocument", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_DOMDocumentPtr, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "DOMDocumentPtr const &","readFromDocument", 2, argv[0] ));
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "DOMDocumentPtr const &","readFromDocument", 2, argv[0]));
}
arg2 = reinterpret_cast< DOMDocumentPtr * >(argp2);
try {
(arg1)->readFromDocument((DOMDocumentPtr const &)*arg2);
}
catch(FIX::ConfigError &_e) {
rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
}
return Qnil;
fail:
return Qnil;
}
|
#readFromStream(*args) ⇒ Object
218365 218366 218367 218368 218369 218370 218371 218372 218373 218374 218375 218376 218377 218378 218379 218380 218381 218382 218383 218384 218385 218386 218387 218388 218389 218390 218391 218392 218393 218394 218395 218396 218397 218398 218399 218400 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218365
SWIGINTERN VALUE
_wrap_DataDictionary_readFromStream(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::istream *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","readFromStream", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__istream, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::istream &","readFromStream", 2, argv[0] ));
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::istream &","readFromStream", 2, argv[0]));
}
arg2 = reinterpret_cast< std::istream * >(argp2);
try {
(arg1)->readFromStream(*arg2);
}
catch(FIX::ConfigError &_e) {
rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
}
return Qnil;
fail:
return Qnil;
}
|
#readFromURL(*args) ⇒ Object
218277 218278 218279 218280 218281 218282 218283 218284 218285 218286 218287 218288 218289 218290 218291 218292 218293 218294 218295 218296 218297 218298 218299 218300 218301 218302 218303 218304 218305 218306 218307 218308 218309 218310 218311 218312 218313 218314 218315 218316 218317 218318 218319 218320 218321 218322 218323 218324 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218277
SWIGINTERN VALUE
_wrap_DataDictionary_readFromURL(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
VALUE vresult = Qnil;
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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","readFromURL", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","readFromURL", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","readFromURL", 2, argv[0]));
}
arg2 = ptr;
}
try {
(arg1)->readFromURL((std::string const &)*arg2);
}
catch(FIX::ConfigError &_e) {
rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__ConfigError, SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN))); SWIG_fail;
}
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#setVersion(*args) ⇒ Object
218539 218540 218541 218542 218543 218544 218545 218546 218547 218548 218549 218550 218551 218552 218553 218554 218555 218556 218557 218558 218559 218560 218561 218562 218563 218564 218565 218566 218567 218568 218569 218570 218571 218572 218573 218574 218575 218576 218577 218578 218579 218580 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 218539
SWIGINTERN VALUE
_wrap_DataDictionary_setVersion(int argc, VALUE *argv, VALUE self) {
FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
std::string *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
VALUE vresult = Qnil;
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_FIX__DataDictionary, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::DataDictionary *","setVersion", 1, self ));
}
arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
{
std::string *ptr = (std::string *)0;
res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setVersion", 2, argv[0] ));
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setVersion", 2, argv[0]));
}
arg2 = ptr;
}
(arg1)->setVersion((std::string const &)*arg2);
{
if( std::string("std::string const &") == "std::string &" )
{
rb_str_resize( argv[0], 0 );
rb_str_append( argv[0], rb_str_new2(arg2->c_str()) );
}
}
if (SWIG_IsNewObj(res2)) delete arg2;
return vresult;
fail:
if (SWIG_IsNewObj(res2)) delete arg2;
return Qnil;
}
|
#validate(*args, self) ⇒ Object
220196 220197 220198 220199 220200 220201 220202 220203 220204 220205 220206 220207 220208 220209 220210 220211 220212 220213 220214 220215 220216 220217 220218 220219 220220 220221 220222 220223 220224 220225 220226 220227 220228 220229 220230 220231 220232 220233 220234 220235 220236 220237 220238 220239 220240 220241 220242 220243 220244 220245 220246 220247 220248 220249 220250 220251 220252 220253 220254 220255 220256 220257 220258 220259 220260 220261 220262 220263 220264 220265 220266 220267 220268 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 220196
SWIGINTERN VALUE _wrap_DataDictionary_validate(int nargs, VALUE *args, VALUE self) {
int argc;
VALUE argv[4];
int ii;
argc = nargs + 1;
argv[0] = self;
if (argc > 4) SWIG_fail;
for (ii = 1; (ii < argc); ++ii) {
argv[ii] = args[ii-1];
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Message, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_DataDictionary_validate__SWIG_1(nargs, args, self);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_DataDictionary_validate__SWIG_0(nargs, args, self);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Message, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_bool(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_DataDictionary_validate__SWIG_2(nargs, args, self);
}
}
}
}
fail:
Ruby_Format_OverloadedError( argc, 4, "DataDictionary.validate",
" void DataDictionary.validate(FIX::DataDictionary const *const pSessionDD, FIX::DataDictionary const *const pAppID)\n"
" void DataDictionary.validate(FIX::Message const &message)\n"
" void DataDictionary.validate(FIX::Message const &message, bool bodyOnly)\n");
return Qnil;
}
|