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
- #getNameValue(*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
111143 111144 111145 111146 111147 111148 111149 111150 111151 111152 111153 111154 111155 111156 111157 111158 111159 111160 111161 111162 111163 111164 111165 111166 111167 111168 111169 111170 111171 111172 111173 111174 111175 111176 111177 111178 111179 111180 111181 111182 111183 111184 111185 111186 111187 111188 111189 111190 111191 111192 111193 111194 111195 111196 111197 111198 111199 111200 111201 111202 111203 111204 111205 111206 111207 111208 111209 111210 111211 111212 111213 111214 111215 111216 111217 111218 111219 111220 111221 111222 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111143 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 = 0; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { return _wrap_new_DataDictionary__SWIG_1(nargs, args, self); } } if (argc == 1) { int _v = 0; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { return _wrap_new_DataDictionary__SWIG_3(nargs, args, self); } } if (argc == 1) { int _v = 0; 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 = 0; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); _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 = 0; 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
111727 111728 111729 111730 111731 111732 111733 111734 111735 111736 111737 111738 111739 111740 111741 111742 111743 111744 111745 111746 111747 111748 111749 111750 111751 111752 111753 111754 111755 111756 111757 111758 111759 111760 111761 111762 111763 111764 111765 111766 111767 111768 111769 111770 111771 111772 111773 111774 111775 111776 111777 111778 111779 111780 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111727 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; } { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->getFieldName(arg2,*arg3); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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
111783 111784 111785 111786 111787 111788 111789 111790 111791 111792 111793 111794 111795 111796 111797 111798 111799 111800 111801 111802 111803 111804 111805 111806 111807 111808 111809 111810 111811 111812 111813 111814 111815 111816 111817 111818 111819 111820 111821 111822 111823 111824 111825 111826 111827 111828 111829 111830 111831 111832 111833 111834 111835 111836 111837 111838 111839 111840 111841 111842 111843 111844 111845 111846 111847 111848 111849 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111783 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; } { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->getFieldTag((std::string const &)*arg2,*arg3); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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
113107 113108 113109 113110 113111 113112 113113 113114 113115 113116 113117 113118 113119 113120 113121 113122 113123 113124 113125 113126 113127 113128 113129 113130 113131 113132 113133 113134 113135 113136 113137 113138 113139 113140 113141 113142 113143 113144 113145 113146 113147 113148 113149 113150 113151 113152 113153 113154 113155 113156 113157 113158 113159 113160 113161 113162 113163 113164 113165 113166 113167 113168 113169 113170 113171 113172 113173 113174 113175 113176 113177 113178 113179 113180 113181 113182 113183 113184 113185 113186 113187 113188 113189 113190 113191 113192 113193 113194 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 113107 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; } { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->getGroup((std::string const &)*arg2,arg3,*arg4,(FIX::DataDictionary const *&)*arg5); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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
111938 111939 111940 111941 111942 111943 111944 111945 111946 111947 111948 111949 111950 111951 111952 111953 111954 111955 111956 111957 111958 111959 111960 111961 111962 111963 111964 111965 111966 111967 111968 111969 111970 111971 111972 111973 111974 111975 111976 111977 111978 111979 111980 111981 111982 111983 111984 111985 111986 111987 111988 111989 111990 111991 111992 111993 111994 111995 111996 111997 111998 111999 112000 112001 112002 112003 112004 112005 112006 112007 112008 112009 112010 112011 112012 112013 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111938 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; } { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->getValueName(arg2,(std::string const &)*arg3,*arg4); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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
111624 111625 111626 111627 111628 111629 111630 111631 111632 111633 111634 111635 111636 111637 111638 111639 111640 111641 111642 111643 111644 111645 111646 111647 111648 111649 111650 111651 111652 111653 111654 111655 111656 111657 111658 111659 111660 111661 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111624 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); { if(tryRubyException([&]() mutable { (arg1)->addField(arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } return Qnil; fail: return Qnil; } |
#addFieldName(*args) ⇒ Object
111664 111665 111666 111667 111668 111669 111670 111671 111672 111673 111674 111675 111676 111677 111678 111679 111680 111681 111682 111683 111684 111685 111686 111687 111688 111689 111690 111691 111692 111693 111694 111695 111696 111697 111698 111699 111700 111701 111702 111703 111704 111705 111706 111707 111708 111709 111710 111711 111712 111713 111714 111715 111716 111717 111718 111719 111720 111721 111722 111723 111724 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111664 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; } { if(tryRubyException([&]() mutable { (arg1)->addFieldName(arg2,(std::string const &)*arg3); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } { 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
112559 112560 112561 112562 112563 112564 112565 112566 112567 112568 112569 112570 112571 112572 112573 112574 112575 112576 112577 112578 112579 112580 112581 112582 112583 112584 112585 112586 112587 112588 112589 112590 112591 112592 112593 112594 112595 112596 112597 112598 112599 112600 112601 112602 112603 112604 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112559 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 ; int 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 *","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); ecode3 = SWIG_AsVal_int(argv[1], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FIX::TYPE::Type","addFieldType", 3, argv[1] )); } arg3 = static_cast< FIX::TYPE::Type >(val3); { if(tryRubyException([&]() mutable { (arg1)->addFieldType(arg2,arg3); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } return Qnil; fail: return Qnil; } |
#addFieldValue(*args) ⇒ Object
112789 112790 112791 112792 112793 112794 112795 112796 112797 112798 112799 112800 112801 112802 112803 112804 112805 112806 112807 112808 112809 112810 112811 112812 112813 112814 112815 112816 112817 112818 112819 112820 112821 112822 112823 112824 112825 112826 112827 112828 112829 112830 112831 112832 112833 112834 112835 112836 112837 112838 112839 112840 112841 112842 112843 112844 112845 112846 112847 112848 112849 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112789 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; } { if(tryRubyException([&]() mutable { (arg1)->addFieldValue(arg2,(std::string const &)*arg3); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } { 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
112960 112961 112962 112963 112964 112965 112966 112967 112968 112969 112970 112971 112972 112973 112974 112975 112976 112977 112978 112979 112980 112981 112982 112983 112984 112985 112986 112987 112988 112989 112990 112991 112992 112993 112994 112995 112996 112997 112998 112999 113000 113001 113002 113003 113004 113005 113006 113007 113008 113009 113010 113011 113012 113013 113014 113015 113016 113017 113018 113019 113020 113021 113022 113023 113024 113025 113026 113027 113028 113029 113030 113031 113032 113033 113034 113035 113036 113037 113038 113039 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112960 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 = 0 ; 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); { if(tryRubyException([&]() mutable { (arg1)->addGroup((std::string const &)*arg2,arg3,arg4,(FIX::DataDictionary const &)*arg5); return self; fail: return Qnil; }) == Qnil) { 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; } |
#addHeaderField(*args) ⇒ Object
112377 112378 112379 112380 112381 112382 112383 112384 112385 112386 112387 112388 112389 112390 112391 112392 112393 112394 112395 112396 112397 112398 112399 112400 112401 112402 112403 112404 112405 112406 112407 112408 112409 112410 112411 112412 112413 112414 112415 112416 112417 112418 112419 112420 112421 112422 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112377 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); { if(tryRubyException([&]() mutable { (arg1)->addHeaderField(arg2,arg3); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } return Qnil; fail: return Qnil; } |
#addMsgField(*args) ⇒ Object
112249 112250 112251 112252 112253 112254 112255 112256 112257 112258 112259 112260 112261 112262 112263 112264 112265 112266 112267 112268 112269 112270 112271 112272 112273 112274 112275 112276 112277 112278 112279 112280 112281 112282 112283 112284 112285 112286 112287 112288 112289 112290 112291 112292 112293 112294 112295 112296 112297 112298 112299 112300 112301 112302 112303 112304 112305 112306 112307 112308 112309 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112249 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); { if(tryRubyException([&]() mutable { (arg1)->addMsgField((std::string const &)*arg2,arg3); return self; fail: return Qnil; }) == Qnil) { 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; } |
#addMsgType(*args) ⇒ Object
112137 112138 112139 112140 112141 112142 112143 112144 112145 112146 112147 112148 112149 112150 112151 112152 112153 112154 112155 112156 112157 112158 112159 112160 112161 112162 112163 112164 112165 112166 112167 112168 112169 112170 112171 112172 112173 112174 112175 112176 112177 112178 112179 112180 112181 112182 112183 112184 112185 112186 112187 112188 112189 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112137 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; } { if(tryRubyException([&]() mutable { (arg1)->addMsgType((std::string const &)*arg2); return self; fail: return Qnil; }) == Qnil) { 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; } |
#addRequiredField(*args) ⇒ Object
112661 112662 112663 112664 112665 112666 112667 112668 112669 112670 112671 112672 112673 112674 112675 112676 112677 112678 112679 112680 112681 112682 112683 112684 112685 112686 112687 112688 112689 112690 112691 112692 112693 112694 112695 112696 112697 112698 112699 112700 112701 112702 112703 112704 112705 112706 112707 112708 112709 112710 112711 112712 112713 112714 112715 112716 112717 112718 112719 112720 112721 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112661 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); { if(tryRubyException([&]() mutable { (arg1)->addRequiredField((std::string const &)*arg2,arg3); return self; fail: return Qnil; }) == Qnil) { 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; } |
#addTrailerField(*args) ⇒ Object
112468 112469 112470 112471 112472 112473 112474 112475 112476 112477 112478 112479 112480 112481 112482 112483 112484 112485 112486 112487 112488 112489 112490 112491 112492 112493 112494 112495 112496 112497 112498 112499 112500 112501 112502 112503 112504 112505 112506 112507 112508 112509 112510 112511 112512 112513 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112468 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); { if(tryRubyException([&]() mutable { (arg1)->addTrailerField(arg2,arg3); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } return Qnil; fail: return Qnil; } |
#addValueName(*args) ⇒ Object
111852 111853 111854 111855 111856 111857 111858 111859 111860 111861 111862 111863 111864 111865 111866 111867 111868 111869 111870 111871 111872 111873 111874 111875 111876 111877 111878 111879 111880 111881 111882 111883 111884 111885 111886 111887 111888 111889 111890 111891 111892 111893 111894 111895 111896 111897 111898 111899 111900 111901 111902 111903 111904 111905 111906 111907 111908 111909 111910 111911 111912 111913 111914 111915 111916 111917 111918 111919 111920 111921 111922 111923 111924 111925 111926 111927 111928 111929 111930 111931 111932 111933 111934 111935 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111852 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; } { if(tryRubyException([&]() mutable { (arg1)->addValueName(arg2,(std::string const &)*arg3,(std::string const &)*arg4); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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
113403 113404 113405 113406 113407 113408 113409 113410 113411 113412 113413 113414 113415 113416 113417 113418 113419 113420 113421 113422 113423 113424 113425 113426 113427 113428 113429 113430 113431 113432 113433 113434 113435 113436 113437 113438 113439 113440 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 113403 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); { if(tryRubyException([&]() mutable { (arg1)->allowUnknownMsgFields(arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } return Qnil; fail: return Qnil; } |
#checkFieldsHaveValues(*args) ⇒ Object
113323 113324 113325 113326 113327 113328 113329 113330 113331 113332 113333 113334 113335 113336 113337 113338 113339 113340 113341 113342 113343 113344 113345 113346 113347 113348 113349 113350 113351 113352 113353 113354 113355 113356 113357 113358 113359 113360 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 113323 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); { if(tryRubyException([&]() mutable { (arg1)->checkFieldsHaveValues(arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } return Qnil; fail: return Qnil; } |
#checkFieldsOutOfOrder(*args) ⇒ Object
113283 113284 113285 113286 113287 113288 113289 113290 113291 113292 113293 113294 113295 113296 113297 113298 113299 113300 113301 113302 113303 113304 113305 113306 113307 113308 113309 113310 113311 113312 113313 113314 113315 113316 113317 113318 113319 113320 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 113283 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); { if(tryRubyException([&]() mutable { (arg1)->checkFieldsOutOfOrder(arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } return Qnil; fail: return Qnil; } |
#checkUserDefinedFields(*args) ⇒ Object
113363 113364 113365 113366 113367 113368 113369 113370 113371 113372 113373 113374 113375 113376 113377 113378 113379 113380 113381 113382 113383 113384 113385 113386 113387 113388 113389 113390 113391 113392 113393 113394 113395 113396 113397 113398 113399 113400 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 113363 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); { if(tryRubyException([&]() mutable { (arg1)->checkUserDefinedFields(arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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
112607 112608 112609 112610 112611 112612 112613 112614 112615 112616 112617 112618 112619 112620 112621 112622 112623 112624 112625 112626 112627 112628 112629 112630 112631 112632 112633 112634 112635 112636 112637 112638 112639 112640 112641 112642 112643 112644 112645 112646 112647 112648 112649 112650 112651 112652 112653 112654 112655 112656 112657 112658 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112607 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); { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->getFieldType(arg2,*arg3); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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
111407 111408 111409 111410 111411 111412 111413 111414 111415 111416 111417 111418 111419 111420 111421 111422 111423 111424 111425 111426 111427 111428 111429 111430 111431 111432 111433 111434 111435 111436 111437 111438 111439 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111407 SWIGINTERN VALUE _wrap_DataDictionary_getHeaderOrderedFields(int argc, VALUE *argv, VALUE self) { FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ; void *argp1 = 0 ; int res1 = 0 ; *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); { if(tryRubyException([&]() mutable { result = ( *) &((FIX::DataDictionary const *)arg1)->getHeaderOrderedFields(); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), , 0 | 0 ); return vresult; fail: return Qnil; } |
#getMessageOrderedFields(*args) ⇒ Object
111477 111478 111479 111480 111481 111482 111483 111484 111485 111486 111487 111488 111489 111490 111491 111492 111493 111494 111495 111496 111497 111498 111499 111500 111501 111502 111503 111504 111505 111506 111507 111508 111509 111510 111511 111512 111513 111514 111515 111516 111517 111518 111519 111520 111521 111522 111523 111524 111525 111526 111527 111528 111529 111530 111531 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111477 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 ; *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; } { if(tryRubyException([&]() mutable { result = ( *) &((FIX::DataDictionary const *)arg1)->getMessageOrderedFields((std::string const &)*arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), , 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; } |
#getNameValue(*args) ⇒ Object
112016 112017 112018 112019 112020 112021 112022 112023 112024 112025 112026 112027 112028 112029 112030 112031 112032 112033 112034 112035 112036 112037 112038 112039 112040 112041 112042 112043 112044 112045 112046 112047 112048 112049 112050 112051 112052 112053 112054 112055 112056 112057 112058 112059 112060 112061 112062 112063 112064 112065 112066 112067 112068 112069 112070 112071 112072 112073 112074 112075 112076 112077 112078 112079 112080 112081 112082 112083 112084 112085 112086 112087 112088 112089 112090 112091 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112016 SWIGINTERN VALUE _wrap_DataDictionary_getNameValue(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 *","getNameValue", 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","getNameValue", 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 &","getNameValue", 3, argv[1] )); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","getNameValue", 3, argv[1])); } arg3 = ptr; } { temp4 = std::string((char*)StringValuePtr(argv[2])); arg4 = &temp4; } { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->getNameValue(arg2,(std::string const &)*arg3,*arg4); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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; } |
#getOrderedFields(*args) ⇒ Object
111372 111373 111374 111375 111376 111377 111378 111379 111380 111381 111382 111383 111384 111385 111386 111387 111388 111389 111390 111391 111392 111393 111394 111395 111396 111397 111398 111399 111400 111401 111402 111403 111404 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111372 SWIGINTERN VALUE _wrap_DataDictionary_getOrderedFields(int argc, VALUE *argv, VALUE self) { FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ; void *argp1 = 0 ; int res1 = 0 ; *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); { if(tryRubyException([&]() mutable { result = ( *) &((FIX::DataDictionary const *)arg1)->getOrderedFields(); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), , 0 | 0 ); return vresult; fail: return Qnil; } |
#getTrailerOrderedFields(*args) ⇒ Object
111442 111443 111444 111445 111446 111447 111448 111449 111450 111451 111452 111453 111454 111455 111456 111457 111458 111459 111460 111461 111462 111463 111464 111465 111466 111467 111468 111469 111470 111471 111472 111473 111474 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111442 SWIGINTERN VALUE _wrap_DataDictionary_getTrailerOrderedFields(int argc, VALUE *argv, VALUE self) { FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ; void *argp1 = 0 ; int res1 = 0 ; *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); { if(tryRubyException([&]() mutable { result = ( *) &((FIX::DataDictionary const *)arg1)->getTrailerOrderedFields(); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), , 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
111589 111590 111591 111592 111593 111594 111595 111596 111597 111598 111599 111600 111601 111602 111603 111604 111605 111606 111607 111608 111609 111610 111611 111612 111613 111614 111615 111616 111617 111618 111619 111620 111621 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111589 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); { if(tryRubyException([&]() mutable { result = ((FIX::DataDictionary const *)arg1)->getVersion(); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } vresult = SWIG_From_std_string(static_cast< std::string >(result)); return vresult; fail: return Qnil; } |
#hasFieldValue(*args) ⇒ Object
112852 112853 112854 112855 112856 112857 112858 112859 112860 112861 112862 112863 112864 112865 112866 112867 112868 112869 112870 112871 112872 112873 112874 112875 112876 112877 112878 112879 112880 112881 112882 112883 112884 112885 112886 112887 112888 112889 112890 112891 112892 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112852 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); { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->hasFieldValue(arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } vresult = SWIG_From_bool(static_cast< bool >(result)); return vresult; fail: return Qnil; } |
#isDataField(*args) ⇒ Object
113197 113198 113199 113200 113201 113202 113203 113204 113205 113206 113207 113208 113209 113210 113211 113212 113213 113214 113215 113216 113217 113218 113219 113220 113221 113222 113223 113224 113225 113226 113227 113228 113229 113230 113231 113232 113233 113234 113235 113236 113237 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 113197 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); { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->isDataField(arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } vresult = SWIG_From_bool(static_cast< bool >(result)); return vresult; fail: return Qnil; } |
#isField(*args) ⇒ Object
112094 112095 112096 112097 112098 112099 112100 112101 112102 112103 112104 112105 112106 112107 112108 112109 112110 112111 112112 112113 112114 112115 112116 112117 112118 112119 112120 112121 112122 112123 112124 112125 112126 112127 112128 112129 112130 112131 112132 112133 112134 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112094 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); { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->isField(arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } vresult = SWIG_From_bool(static_cast< bool >(result)); return vresult; fail: return Qnil; } |
#isFieldValue(*args) ⇒ Object
112895 112896 112897 112898 112899 112900 112901 112902 112903 112904 112905 112906 112907 112908 112909 112910 112911 112912 112913 112914 112915 112916 112917 112918 112919 112920 112921 112922 112923 112924 112925 112926 112927 112928 112929 112930 112931 112932 112933 112934 112935 112936 112937 112938 112939 112940 112941 112942 112943 112944 112945 112946 112947 112948 112949 112950 112951 112952 112953 112954 112955 112956 112957 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112895 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; } { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->isFieldValue(arg2,(std::string const &)*arg3); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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
113042 113043 113044 113045 113046 113047 113048 113049 113050 113051 113052 113053 113054 113055 113056 113057 113058 113059 113060 113061 113062 113063 113064 113065 113066 113067 113068 113069 113070 113071 113072 113073 113074 113075 113076 113077 113078 113079 113080 113081 113082 113083 113084 113085 113086 113087 113088 113089 113090 113091 113092 113093 113094 113095 113096 113097 113098 113099 113100 113101 113102 113103 113104 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 113042 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); { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->isGroup((std::string const &)*arg2,arg3); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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
112425 112426 112427 112428 112429 112430 112431 112432 112433 112434 112435 112436 112437 112438 112439 112440 112441 112442 112443 112444 112445 112446 112447 112448 112449 112450 112451 112452 112453 112454 112455 112456 112457 112458 112459 112460 112461 112462 112463 112464 112465 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112425 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); { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->isHeaderField(arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } vresult = SWIG_From_bool(static_cast< bool >(result)); return vresult; fail: return Qnil; } |
#isMessageFieldsOrderPreserved(*args) ⇒ Object
113483 113484 113485 113486 113487 113488 113489 113490 113491 113492 113493 113494 113495 113496 113497 113498 113499 113500 113501 113502 113503 113504 113505 113506 113507 113508 113509 113510 113511 113512 113513 113514 113515 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 113483 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); { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->isMessageFieldsOrderPreserved(); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } vresult = SWIG_From_bool(static_cast< bool >(result)); return vresult; fail: return Qnil; } |
#isMsgField(*args) ⇒ Object
112312 112313 112314 112315 112316 112317 112318 112319 112320 112321 112322 112323 112324 112325 112326 112327 112328 112329 112330 112331 112332 112333 112334 112335 112336 112337 112338 112339 112340 112341 112342 112343 112344 112345 112346 112347 112348 112349 112350 112351 112352 112353 112354 112355 112356 112357 112358 112359 112360 112361 112362 112363 112364 112365 112366 112367 112368 112369 112370 112371 112372 112373 112374 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112312 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); { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->isMsgField((std::string const &)*arg2,arg3); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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
112192 112193 112194 112195 112196 112197 112198 112199 112200 112201 112202 112203 112204 112205 112206 112207 112208 112209 112210 112211 112212 112213 112214 112215 112216 112217 112218 112219 112220 112221 112222 112223 112224 112225 112226 112227 112228 112229 112230 112231 112232 112233 112234 112235 112236 112237 112238 112239 112240 112241 112242 112243 112244 112245 112246 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112192 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; } { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->isMsgType((std::string const &)*arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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
113240 113241 113242 113243 113244 113245 113246 113247 113248 113249 113250 113251 113252 113253 113254 113255 113256 113257 113258 113259 113260 113261 113262 113263 113264 113265 113266 113267 113268 113269 113270 113271 113272 113273 113274 113275 113276 113277 113278 113279 113280 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 113240 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); { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->isMultipleValueField(arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } vresult = SWIG_From_bool(static_cast< bool >(result)); return vresult; fail: return Qnil; } |
#isRequiredField(*args) ⇒ Object
112724 112725 112726 112727 112728 112729 112730 112731 112732 112733 112734 112735 112736 112737 112738 112739 112740 112741 112742 112743 112744 112745 112746 112747 112748 112749 112750 112751 112752 112753 112754 112755 112756 112757 112758 112759 112760 112761 112762 112763 112764 112765 112766 112767 112768 112769 112770 112771 112772 112773 112774 112775 112776 112777 112778 112779 112780 112781 112782 112783 112784 112785 112786 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112724 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); { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->isRequiredField((std::string const &)*arg2,arg3); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } 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
112516 112517 112518 112519 112520 112521 112522 112523 112524 112525 112526 112527 112528 112529 112530 112531 112532 112533 112534 112535 112536 112537 112538 112539 112540 112541 112542 112543 112544 112545 112546 112547 112548 112549 112550 112551 112552 112553 112554 112555 112556 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 112516 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); { if(tryRubyException([&]() mutable { result = (bool)((FIX::DataDictionary const *)arg1)->isTrailerField(arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } vresult = SWIG_From_bool(static_cast< bool >(result)); return vresult; fail: return Qnil; } |
#preserveMessageFieldsOrder(*args) ⇒ Object
113443 113444 113445 113446 113447 113448 113449 113450 113451 113452 113453 113454 113455 113456 113457 113458 113459 113460 113461 113462 113463 113464 113465 113466 113467 113468 113469 113470 113471 113472 113473 113474 113475 113476 113477 113478 113479 113480 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 113443 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); { if(tryRubyException([&]() mutable { (arg1)->preserveMessageFieldsOrder(arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } return Qnil; fail: return Qnil; } |
#readFromDocument(*args) ⇒ Object
111286 111287 111288 111289 111290 111291 111292 111293 111294 111295 111296 111297 111298 111299 111300 111301 111302 111303 111304 111305 111306 111307 111308 111309 111310 111311 111312 111313 111314 111315 111316 111317 111318 111319 111320 111321 111322 111323 111324 111325 111326 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111286 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 = 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 *","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); { if(tryRubyException([&]() mutable { (arg1)->readFromDocument((DOMDocumentPtr const &)*arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } return Qnil; fail: return Qnil; } |
#readFromStream(*args) ⇒ Object
111329 111330 111331 111332 111333 111334 111335 111336 111337 111338 111339 111340 111341 111342 111343 111344 111345 111346 111347 111348 111349 111350 111351 111352 111353 111354 111355 111356 111357 111358 111359 111360 111361 111362 111363 111364 111365 111366 111367 111368 111369 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111329 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); { if(tryRubyException([&]() mutable { (arg1)->readFromStream(*arg2); return self; fail: return Qnil; }) == Qnil) { SWIG_fail; } } return Qnil; fail: return Qnil; } |
#readFromURL(*args) ⇒ Object
111231 111232 111233 111234 111235 111236 111237 111238 111239 111240 111241 111242 111243 111244 111245 111246 111247 111248 111249 111250 111251 111252 111253 111254 111255 111256 111257 111258 111259 111260 111261 111262 111263 111264 111265 111266 111267 111268 111269 111270 111271 111272 111273 111274 111275 111276 111277 111278 111279 111280 111281 111282 111283 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111231 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; } { if(tryRubyException([&]() mutable { (arg1)->readFromURL((std::string const &)*arg2); return self; fail: return Qnil; }) == Qnil) { 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
111534 111535 111536 111537 111538 111539 111540 111541 111542 111543 111544 111545 111546 111547 111548 111549 111550 111551 111552 111553 111554 111555 111556 111557 111558 111559 111560 111561 111562 111563 111564 111565 111566 111567 111568 111569 111570 111571 111572 111573 111574 111575 111576 111577 111578 111579 111580 111581 111582 111583 111584 111585 111586 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 111534 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; } { if(tryRubyException([&]() mutable { (arg1)->setVersion((std::string const &)*arg2); return self; fail: return Qnil; }) == Qnil) { 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; } |
#validate(*args, self) ⇒ Object
113663 113664 113665 113666 113667 113668 113669 113670 113671 113672 113673 113674 113675 113676 113677 113678 113679 113680 113681 113682 113683 113684 113685 113686 113687 113688 113689 113690 113691 113692 113693 113694 113695 113696 113697 113698 113699 113700 113701 113702 113703 113704 113705 113706 113707 113708 113709 113710 113711 113712 113713 113714 113715 113716 113717 113718 113719 113720 113721 113722 113723 113724 113725 113726 113727 113728 113729 113730 113731 113732 113733 113734 113735 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 113663 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 = 0; 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, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { return _wrap_DataDictionary_validate__SWIG_1(nargs, args, self); } } } if (argc == 3) { int _v = 0; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, SWIG_POINTER_NO_NULL); _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 = 0; 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, SWIG_POINTER_NO_NULL); _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; } |