Class: Quickfix::SessionIDSet
- Inherits:
-
Object
- Object
- Quickfix::SessionIDSet
- Defined in:
- ext/quickfix/QuickfixRuby.cpp
Instance Method Summary collapse
-
#[](*args) ⇒ Object
call-seq: [](i) -> SessionID.
- #__delete2__(*args) ⇒ Object
-
#begin(*args) ⇒ Object
call-seq: begin -> std::set< FIX::SessionID >::iterator.
-
#clear(*args) ⇒ Object
call-seq: clear.
- #count(*args) ⇒ Object
-
#delete_at(*args) ⇒ Object
call-seq: delete_at(i) -> VALUE.
-
#dup(*args) ⇒ Object
call-seq: dup -> SessionIDSet.
-
#each(*args) ⇒ Object
call-seq: each -> SessionIDSet.
-
#empty?(*args) ⇒ Boolean
call-seq: empty? -> bool.
-
#end(*args) ⇒ Object
call-seq: end -> std::set< FIX::SessionID >::iterator.
- #equal_range(*args) ⇒ Object
-
#erase(*args, self) ⇒ Object
call-seq: erase(x) -> std::set< FIX::SessionID >::size_type erase(pos) erase(first, last).
-
#find(*args) ⇒ Object
call-seq: find(x) -> std::set< FIX::SessionID >::iterator.
- #include?(*args) ⇒ Boolean
- #initialize(*args, self) ⇒ Object constructor
-
#insert(*args) ⇒ Object
call-seq: insert(x) -> std::pair< std::set< FIX::SessionID >::iterator,bool >.
-
#inspect(*args) ⇒ Object
call-seq: inspect -> VALUE.
- #lower_bound(*args) ⇒ Object
-
#push(*args) ⇒ Object
(also: #<<)
call-seq: push(x) -> SessionID.
-
#rbegin(*args) ⇒ Object
call-seq: rbegin -> std::set< FIX::SessionID >::reverse_iterator.
-
#reject!(*args) ⇒ Object
(also: #delete_if)
call-seq: reject! -> SessionIDSet.
-
#rend(*args) ⇒ Object
call-seq: rend -> std::set< FIX::SessionID >::reverse_iterator.
-
#select(*args) ⇒ Object
call-seq: select -> SessionIDSet.
-
#size(*args) ⇒ Object
call-seq: size -> std::set< FIX::SessionID >::size_type.
-
#slice(*args) ⇒ Object
call-seq: slice(i, length) -> VALUE.
- #swap(*args) ⇒ Object
-
#to_a(*args) ⇒ Object
call-seq: to_a -> VALUE.
-
#to_s(*args) ⇒ Object
call-seq: to_s -> VALUE.
- #upper_bound(*args) ⇒ Object
Constructor Details
#initialize(*args, self) ⇒ Object
11932 11933 11934 11935 11936 11937 11938 11939 11940 11941 11942 11943 11944 11945 11946 11947 11948 11949 11950 11951 11952 11953 11954 11955 11956 11957 11958 11959 11960 11961 11962 11963 11964 11965 11966 11967 11968 11969 11970 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11932
SWIGINTERN VALUE _wrap_new_SessionIDSet(int nargs, VALUE *args, VALUE self) {
int argc;
VALUE argv[1];
int ii;
argc = nargs;
if (argc > 1) SWIG_fail;
for (ii = 0; (ii < argc); ++ii) {
argv[ii] = args[ii];
}
if (argc == 0) {
return _wrap_new_SessionIDSet__SWIG_1(nargs, args, self);
}
if (argc == 1) {
int _v = 0;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__lessT_FIX__SessionID_t, SWIG_POINTER_NO_NULL);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_SessionIDSet__SWIG_0(nargs, args, self);
}
}
if (argc == 1) {
int _v = 0;
int res = swig::asptr(argv[0], (std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_SessionIDSet__SWIG_2(nargs, args, self);
}
}
fail:
Ruby_Format_OverloadedError( argc, 1, "SessionIDSet.new",
" SessionIDSet.new(std::less< FIX::SessionID > const &other)\n"
" SessionIDSet.new()\n"
" SessionIDSet.new(std::set< FIX::SessionID > const &other)\n");
return Qnil;
}
|
Instance Method Details
#[](*args) ⇒ Object
call-seq:
[](i) -> SessionID
Element accessor/slicing.
11801 11802 11803 11804 11805 11806 11807 11808 11809 11810 11811 11812 11813 11814 11815 11816 11817 11818 11819 11820 11821 11822 11823 11824 11825 11826 11827 11828 11829 11830 11831 11832 11833 11834 11835 11836 11837 11838 11839 11840 11841 11842 11843 11844 11845 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11801
SWIGINTERN VALUE
_wrap_SessionIDSet___getitem__(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
std::set< FIX::SessionID >::value_type 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > const *","__getitem__", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::difference_type","__getitem__", 2, argv[0] ));
}
arg2 = static_cast< std::set< FIX::SessionID >::difference_type >(val2);
{
if(tryRubyException([&]() mutable
{
try {
result = std_set_Sl_FIX_SessionID_Sg____getitem__((std::set< FIX::SessionID > const *)arg1,SWIG_STD_MOVE(arg2));
} catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj((new std::set< FIX::SessionID >::value_type(result)), SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_OWN | 0 );
return vresult;
fail:
return Qnil;
}
|
#__delete2__(*args) ⇒ Object
11510 11511 11512 11513 11514 11515 11516 11517 11518 11519 11520 11521 11522 11523 11524 11525 11526 11527 11528 11529 11530 11531 11532 11533 11534 11535 11536 11537 11538 11539 11540 11541 11542 11543 11544 11545 11546 11547 11548 11549 11550 11551 11552 11553 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11510
SWIGINTERN VALUE
_wrap_SessionIDSet___delete2__(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
VALUE 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","__delete2__", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::value_type const &","__delete2__", 2, argv[0] ));
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::set< FIX::SessionID >::value_type const &","__delete2__", 2, argv[0]));
}
arg2 = reinterpret_cast< std::set< FIX::SessionID >::value_type * >(argp2);
{
if(tryRubyException([&]() mutable
{
result = (VALUE)std_set_Sl_FIX_SessionID_Sg____delete2__(arg1,(FIX::SessionID const &)*arg2);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = result;
return vresult;
fail:
return Qnil;
}
|
#begin(*args) ⇒ Object
call-seq:
begin -> std::set< FIX::SessionID >::iterator
Return an iterator to the beginning of the SessionIDSet.
12252 12253 12254 12255 12256 12257 12258 12259 12260 12261 12262 12263 12264 12265 12266 12267 12268 12269 12270 12271 12272 12273 12274 12275 12276 12277 12278 12279 12280 12281 12282 12283 12284 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12252
SWIGINTERN VALUE
_wrap_SessionIDSet_begin(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::set< FIX::SessionID >::iterator 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","begin", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = (arg1)->begin();
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj((swig::make_set_nonconst_iterator<std::set< FIX::SessionID >::iterator>(result, self)), swig::Iterator::descriptor(), SWIG_POINTER_OWN);
return vresult;
fail:
return Qnil;
}
|
#clear(*args) ⇒ Object
call-seq:
clear
Clear SessionIDSet contents.
12067 12068 12069 12070 12071 12072 12073 12074 12075 12076 12077 12078 12079 12080 12081 12082 12083 12084 12085 12086 12087 12088 12089 12090 12091 12092 12093 12094 12095 12096 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12067
SWIGINTERN VALUE
_wrap_SessionIDSet_clear(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","clear", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
(arg1)->clear();
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
return Qnil;
fail:
return Qnil;
}
|
#count(*args) ⇒ Object
12198 12199 12200 12201 12202 12203 12204 12205 12206 12207 12208 12209 12210 12211 12212 12213 12214 12215 12216 12217 12218 12219 12220 12221 12222 12223 12224 12225 12226 12227 12228 12229 12230 12231 12232 12233 12234 12235 12236 12237 12238 12239 12240 12241 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12198
SWIGINTERN VALUE
_wrap_SessionIDSet_count(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID >::key_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
std::set< FIX::SessionID >::size_type 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > const *","count", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::key_type const &","count", 2, argv[0] ));
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::set< FIX::SessionID >::key_type const &","count", 2, argv[0]));
}
arg2 = reinterpret_cast< std::set< FIX::SessionID >::key_type * >(argp2);
{
if(tryRubyException([&]() mutable
{
result = ((std::set< FIX::SessionID > const *)arg1)->count((std::set< FIX::SessionID >::key_type const &)*arg2);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_From_size_t(static_cast< size_t >(result));
return vresult;
fail:
return Qnil;
}
|
#delete_at(*args) ⇒ Object
call-seq:
delete_at(i) -> VALUE
Delete an element at a certain index.
11607 11608 11609 11610 11611 11612 11613 11614 11615 11616 11617 11618 11619 11620 11621 11622 11623 11624 11625 11626 11627 11628 11629 11630 11631 11632 11633 11634 11635 11636 11637 11638 11639 11640 11641 11642 11643 11644 11645 11646 11647 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11607
SWIGINTERN VALUE
_wrap_SessionIDSet_delete_at(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
VALUE 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","delete_at", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::difference_type","delete_at", 2, argv[0] ));
}
arg2 = static_cast< std::set< FIX::SessionID >::difference_type >(val2);
{
if(tryRubyException([&]() mutable
{
result = (VALUE)std_set_Sl_FIX_SessionID_Sg__delete_at(arg1,SWIG_STD_MOVE(arg2));
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = result;
return vresult;
fail:
return Qnil;
}
|
#dup(*args) ⇒ Object
call-seq:
dup -> SessionIDSet
Create a duplicate of the class and unfreeze it if needed.
11240 11241 11242 11243 11244 11245 11246 11247 11248 11249 11250 11251 11252 11253 11254 11255 11256 11257 11258 11259 11260 11261 11262 11263 11264 11265 11266 11267 11268 11269 11270 11271 11272 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11240
SWIGINTERN VALUE
_wrap_SessionIDSet_dup(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","dup", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = (std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *)std_set_Sl_FIX_SessionID_Sg__dup(arg1);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_FIX__SessionID_t, SWIG_POINTER_OWN | 0 );
return vresult;
fail:
return Qnil;
}
|
#each(*args) ⇒ Object
call-seq:
each -> SessionIDSet
Iterate thru each element in the SessionIDSet. A block must be provided.
11475 11476 11477 11478 11479 11480 11481 11482 11483 11484 11485 11486 11487 11488 11489 11490 11491 11492 11493 11494 11495 11496 11497 11498 11499 11500 11501 11502 11503 11504 11505 11506 11507 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11475
SWIGINTERN VALUE
_wrap_SessionIDSet_each(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","each", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = (std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *)std_set_Sl_FIX_SessionID_Sg__each(arg1);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 | 0 );
return vresult;
fail:
return Qnil;
}
|
#empty?(*args) ⇒ Boolean
call-seq:
empty? -> bool
Check if the SessionIDSet is empty or not.
11981 11982 11983 11984 11985 11986 11987 11988 11989 11990 11991 11992 11993 11994 11995 11996 11997 11998 11999 12000 12001 12002 12003 12004 12005 12006 12007 12008 12009 12010 12011 12012 12013 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11981
SWIGINTERN VALUE
_wrap_SessionIDSet_emptyq___(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > const *","empty", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = (bool)((std::set< FIX::SessionID > const *)arg1)->empty();
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_From_bool(static_cast< bool >(result));
return vresult;
fail:
return Qnil;
}
|
#end(*args) ⇒ Object
call-seq:
end -> std::set< FIX::SessionID >::iterator
Return an iterator to past the end of the SessionIDSet.
12295 12296 12297 12298 12299 12300 12301 12302 12303 12304 12305 12306 12307 12308 12309 12310 12311 12312 12313 12314 12315 12316 12317 12318 12319 12320 12321 12322 12323 12324 12325 12326 12327 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12295
SWIGINTERN VALUE
_wrap_SessionIDSet_end(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::set< FIX::SessionID >::iterator 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","end", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = (arg1)->end();
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj((swig::make_set_nonconst_iterator<std::set< FIX::SessionID >::iterator>(result, self)), swig::Iterator::descriptor(), SWIG_POINTER_OWN);
return vresult;
fail:
return Qnil;
}
|
#equal_range(*args) ⇒ Object
12744 12745 12746 12747 12748 12749 12750 12751 12752 12753 12754 12755 12756 12757 12758 12759 12760 12761 12762 12763 12764 12765 12766 12767 12768 12769 12770 12771 12772 12773 12774 12775 12776 12777 12778 12779 12780 12781 12782 12783 12784 12785 12786 12787 12788 12789 12790 12791 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12744
SWIGINTERN VALUE
_wrap_SessionIDSet_equal_range(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID >::key_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
SwigValueWrapper< std::pair< std::set< FIX::SessionID >::iterator,std::set< FIX::SessionID >::iterator > > 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","equal_range", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::key_type const &","equal_range", 2, argv[0] ));
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::set< FIX::SessionID >::key_type const &","equal_range", 2, argv[0]));
}
arg2 = reinterpret_cast< std::set< FIX::SessionID >::key_type * >(argp2);
{
if(tryRubyException([&]() mutable
{
result = (arg1)->equal_range((std::set< FIX::SessionID >::key_type const &)*arg2);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = rb_ary_new2(2);
rb_ary_push(vresult, SWIG_NewPointerObj(swig::make_const_iterator(static_cast< const std::pair< std::set< FIX::SessionID >::iterator,std::set< FIX::SessionID >::iterator > & >(result).first),
swig::ConstIterator::descriptor(),SWIG_POINTER_OWN));
rb_ary_push(vresult, SWIG_NewPointerObj(swig::make_const_iterator(static_cast< const std::pair< std::set< FIX::SessionID >::iterator,std::set< FIX::SessionID >::iterator > & >(result).second),
swig::ConstIterator::descriptor(),SWIG_POINTER_OWN));
return vresult;
fail:
return Qnil;
}
|
#erase(*args, self) ⇒ Object
call-seq:
erase(x) -> std::set< FIX::SessionID >::size_type
erase(pos)
erase(first, last)
Delete a portion of the SessionIDSet.
12532 12533 12534 12535 12536 12537 12538 12539 12540 12541 12542 12543 12544 12545 12546 12547 12548 12549 12550 12551 12552 12553 12554 12555 12556 12557 12558 12559 12560 12561 12562 12563 12564 12565 12566 12567 12568 12569 12570 12571 12572 12573 12574 12575 12576 12577 12578 12579 12580 12581 12582 12583 12584 12585 12586 12587 12588 12589 12590 12591 12592 12593 12594 12595 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12532
SWIGINTERN VALUE _wrap_SessionIDSet_erase(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;
int res = swig::asptr(argv[0], (std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_SessionIDSet_erase__SWIG_0(nargs, args, self);
}
}
}
if (argc == 2) {
int _v = 0;
int res = swig::asptr(argv[0], (std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::ConstIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::set< FIX::SessionID >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_SessionIDSet_erase__SWIG_1(nargs, args, self);
}
}
}
if (argc == 3) {
int _v = 0;
int res = swig::asptr(argv[0], (std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::ConstIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::set< FIX::SessionID >::iterator > *>(iter) != 0));
if (_v) {
swig::ConstIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::set< FIX::SessionID >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_SessionIDSet_erase__SWIG_2(nargs, args, self);
}
}
}
}
fail:
Ruby_Format_OverloadedError( argc, 4, "SessionIDSet.erase",
" std::set< FIX::SessionID >::size_type SessionIDSet.erase(std::set< FIX::SessionID >::key_type const &x)\n"
" void SessionIDSet.erase(std::set< FIX::SessionID >::iterator pos)\n"
" void SessionIDSet.erase(std::set< FIX::SessionID >::iterator first, std::set< FIX::SessionID >::iterator last)\n");
return Qnil;
}
|
#find(*args) ⇒ Object
call-seq:
find(x) -> std::set< FIX::SessionID >::iterator
Find an element in the class.
12606 12607 12608 12609 12610 12611 12612 12613 12614 12615 12616 12617 12618 12619 12620 12621 12622 12623 12624 12625 12626 12627 12628 12629 12630 12631 12632 12633 12634 12635 12636 12637 12638 12639 12640 12641 12642 12643 12644 12645 12646 12647 12648 12649 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12606
SWIGINTERN VALUE
_wrap_SessionIDSet_find(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID >::key_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
std::set< FIX::SessionID >::iterator 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","find", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::key_type const &","find", 2, argv[0] ));
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::set< FIX::SessionID >::key_type const &","find", 2, argv[0]));
}
arg2 = reinterpret_cast< std::set< FIX::SessionID >::key_type * >(argp2);
{
if(tryRubyException([&]() mutable
{
result = (arg1)->find((std::set< FIX::SessionID >::key_type const &)*arg2);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj((swig::make_set_nonconst_iterator<std::set< FIX::SessionID >::iterator>(result, self)), swig::Iterator::descriptor(), SWIG_POINTER_OWN);
return vresult;
fail:
return Qnil;
}
|
#include?(*args) ⇒ Boolean
11747 11748 11749 11750 11751 11752 11753 11754 11755 11756 11757 11758 11759 11760 11761 11762 11763 11764 11765 11766 11767 11768 11769 11770 11771 11772 11773 11774 11775 11776 11777 11778 11779 11780 11781 11782 11783 11784 11785 11786 11787 11788 11789 11790 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11747
SWIGINTERN VALUE
_wrap_SessionIDSet_includeq___(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","__contains__", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::value_type const &","__contains__", 2, argv[0] ));
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::set< FIX::SessionID >::value_type const &","__contains__", 2, argv[0]));
}
arg2 = reinterpret_cast< std::set< FIX::SessionID >::value_type * >(argp2);
{
if(tryRubyException([&]() mutable
{
result = (bool)std_set_Sl_FIX_SessionID_Sg____contains__(arg1,(FIX::SessionID const &)*arg2);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_From_bool(static_cast< bool >(result));
return vresult;
fail:
return Qnil;
}
|
#insert(*args) ⇒ Object
call-seq:
insert(x) -> std::pair< std::set< FIX::SessionID >::iterator,bool >
Insert one or more new elements in the SessionIDSet.
12802 12803 12804 12805 12806 12807 12808 12809 12810 12811 12812 12813 12814 12815 12816 12817 12818 12819 12820 12821 12822 12823 12824 12825 12826 12827 12828 12829 12830 12831 12832 12833 12834 12835 12836 12837 12838 12839 12840 12841 12842 12843 12844 12845 12846 12847 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12802
SWIGINTERN VALUE
_wrap_SessionIDSet_insert(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
SwigValueWrapper< std::pair< std::set< FIX::SessionID >::iterator,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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","insert", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::value_type const &","insert", 2, argv[0] ));
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::set< FIX::SessionID >::value_type const &","insert", 2, argv[0]));
}
arg2 = reinterpret_cast< std::set< FIX::SessionID >::value_type * >(argp2);
{
if(tryRubyException([&]() mutable
{
result = (arg1)->insert((std::set< FIX::SessionID >::value_type const &)*arg2);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = rb_ary_new2(2);
rb_ary_push(vresult, SWIG_NewPointerObj((swig::make_set_nonconst_iterator((&result)->first)), swig::Iterator::descriptor(), SWIG_POINTER_OWN));
rb_ary_push(vresult, SWIG_From_bool (static_cast< const std::pair< std::set< FIX::SessionID >::iterator,bool > & >(result).second));
return vresult;
fail:
return Qnil;
}
|
#inspect(*args) ⇒ Object
call-seq:
inspect -> VALUE
Inspect class and its contents.
11283 11284 11285 11286 11287 11288 11289 11290 11291 11292 11293 11294 11295 11296 11297 11298 11299 11300 11301 11302 11303 11304 11305 11306 11307 11308 11309 11310 11311 11312 11313 11314 11315 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11283
SWIGINTERN VALUE
_wrap_SessionIDSet_inspect(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
VALUE 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","inspect", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = (VALUE)std_set_Sl_FIX_SessionID_Sg__inspect(arg1);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = result;
return vresult;
fail:
return Qnil;
}
|
#lower_bound(*args) ⇒ Object
12652 12653 12654 12655 12656 12657 12658 12659 12660 12661 12662 12663 12664 12665 12666 12667 12668 12669 12670 12671 12672 12673 12674 12675 12676 12677 12678 12679 12680 12681 12682 12683 12684 12685 12686 12687 12688 12689 12690 12691 12692 12693 12694 12695 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12652
SWIGINTERN VALUE
_wrap_SessionIDSet_lower_bound(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID >::key_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
std::set< FIX::SessionID >::iterator 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","lower_bound", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::key_type const &","lower_bound", 2, argv[0] ));
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::set< FIX::SessionID >::key_type const &","lower_bound", 2, argv[0]));
}
arg2 = reinterpret_cast< std::set< FIX::SessionID >::key_type * >(argp2);
{
if(tryRubyException([&]() mutable
{
result = (arg1)->lower_bound((std::set< FIX::SessionID >::key_type const &)*arg2);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj((swig::make_set_nonconst_iterator<std::set< FIX::SessionID >::iterator>(result, self)), swig::Iterator::descriptor(), SWIG_POINTER_OWN);
return vresult;
fail:
return Qnil;
}
|
#push(*args) ⇒ Object Also known as: <<
call-seq:
push(x) -> SessionID
Add an element at the end of the SessionIDSet.
11701 11702 11703 11704 11705 11706 11707 11708 11709 11710 11711 11712 11713 11714 11715 11716 11717 11718 11719 11720 11721 11722 11723 11724 11725 11726 11727 11728 11729 11730 11731 11732 11733 11734 11735 11736 11737 11738 11739 11740 11741 11742 11743 11744 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11701
SWIGINTERN VALUE
_wrap_SessionIDSet_push(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
std::set< FIX::SessionID >::value_type 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","push", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::value_type const &","push", 2, argv[0] ));
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::set< FIX::SessionID >::value_type const &","push", 2, argv[0]));
}
arg2 = reinterpret_cast< std::set< FIX::SessionID >::value_type * >(argp2);
{
if(tryRubyException([&]() mutable
{
result = std_set_Sl_FIX_SessionID_Sg__push(arg1,(FIX::SessionID const &)*arg2);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj((new std::set< FIX::SessionID >::value_type(result)), SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_OWN | 0 );
return vresult;
fail:
return Qnil;
}
|
#rbegin(*args) ⇒ Object
call-seq:
rbegin -> std::set< FIX::SessionID >::reverse_iterator
Return a reverse iterator to the beginning (the end) of the SessionIDSet.
12338 12339 12340 12341 12342 12343 12344 12345 12346 12347 12348 12349 12350 12351 12352 12353 12354 12355 12356 12357 12358 12359 12360 12361 12362 12363 12364 12365 12366 12367 12368 12369 12370 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12338
SWIGINTERN VALUE
_wrap_SessionIDSet_rbegin(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::set< FIX::SessionID >::reverse_iterator 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","rbegin", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = (arg1)->rbegin();
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj((swig::make_set_nonconst_iterator<std::set< FIX::SessionID >::reverse_iterator>(result, self)), swig::Iterator::descriptor(), SWIG_POINTER_OWN);
return vresult;
fail:
return Qnil;
}
|
#reject!(*args) ⇒ Object Also known as: delete_if
call-seq:
reject! -> SessionIDSet
Iterate thru each element in the SessionIDSet and reject those that fail a condition. A block must be provided. SessionIDSet is modified in place.
11658 11659 11660 11661 11662 11663 11664 11665 11666 11667 11668 11669 11670 11671 11672 11673 11674 11675 11676 11677 11678 11679 11680 11681 11682 11683 11684 11685 11686 11687 11688 11689 11690 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11658
SWIGINTERN VALUE
_wrap_SessionIDSet_rejectN___(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","reject_bang", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = (std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *)std_set_Sl_FIX_SessionID_Sg__reject_bang(arg1);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 | 0 );
return vresult;
fail:
return Qnil;
}
|
#rend(*args) ⇒ Object
call-seq:
rend -> std::set< FIX::SessionID >::reverse_iterator
Return a reverse iterator to past the end (past the beginning) of the SessionIDSet.
12381 12382 12383 12384 12385 12386 12387 12388 12389 12390 12391 12392 12393 12394 12395 12396 12397 12398 12399 12400 12401 12402 12403 12404 12405 12406 12407 12408 12409 12410 12411 12412 12413 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12381
SWIGINTERN VALUE
_wrap_SessionIDSet_rend(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::set< FIX::SessionID >::reverse_iterator 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","rend", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = (arg1)->rend();
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj((swig::make_set_nonconst_iterator<std::set< FIX::SessionID >::reverse_iterator>(result, self)), swig::Iterator::descriptor(), SWIG_POINTER_OWN);
return vresult;
fail:
return Qnil;
}
|
#select(*args) ⇒ Object
call-seq:
select -> SessionIDSet
Iterate thru each element in the SessionIDSet and select those that match a condition. A block must be provided.
11564 11565 11566 11567 11568 11569 11570 11571 11572 11573 11574 11575 11576 11577 11578 11579 11580 11581 11582 11583 11584 11585 11586 11587 11588 11589 11590 11591 11592 11593 11594 11595 11596 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11564
SWIGINTERN VALUE
_wrap_SessionIDSet_select(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","select", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = (std::set< FIX::SessionID,std::less< FIX::SessionID >,std::allocator< FIX::SessionID > > *)std_set_Sl_FIX_SessionID_Sg__select(arg1);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_FIX__SessionID_t, SWIG_POINTER_OWN | 0 );
return vresult;
fail:
return Qnil;
}
|
#size(*args) ⇒ Object
call-seq:
size -> std::set< FIX::SessionID >::size_type
Size or Length of the SessionIDSet.
12024 12025 12026 12027 12028 12029 12030 12031 12032 12033 12034 12035 12036 12037 12038 12039 12040 12041 12042 12043 12044 12045 12046 12047 12048 12049 12050 12051 12052 12053 12054 12055 12056 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12024
SWIGINTERN VALUE
_wrap_SessionIDSet_size(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::set< FIX::SessionID >::size_type 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > const *","size", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = ((std::set< FIX::SessionID > const *)arg1)->size();
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_From_size_t(static_cast< size_t >(result));
return vresult;
fail:
return Qnil;
}
|
#slice(*args) ⇒ Object
call-seq:
slice(i, length) -> VALUE
Return a slice (portion of) the SessionIDSet.
11412 11413 11414 11415 11416 11417 11418 11419 11420 11421 11422 11423 11424 11425 11426 11427 11428 11429 11430 11431 11432 11433 11434 11435 11436 11437 11438 11439 11440 11441 11442 11443 11444 11445 11446 11447 11448 11449 11450 11451 11452 11453 11454 11455 11456 11457 11458 11459 11460 11461 11462 11463 11464 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11412
SWIGINTERN VALUE
_wrap_SessionIDSet_slice(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID >::difference_type arg2 ;
std::set< FIX::SessionID >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
ptrdiff_t val3 ;
int ecode3 = 0 ;
VALUE 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","slice", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::difference_type","slice", 2, argv[0] ));
}
arg2 = static_cast< std::set< FIX::SessionID >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::difference_type","slice", 3, argv[1] ));
}
arg3 = static_cast< std::set< FIX::SessionID >::difference_type >(val3);
{
if(tryRubyException([&]() mutable
{
try {
result = (VALUE)std_set_Sl_FIX_SessionID_Sg__slice(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
} catch(std::invalid_argument &_e) {
SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
}
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = result;
return vresult;
fail:
return Qnil;
}
|
#swap(*args) ⇒ Object
12099 12100 12101 12102 12103 12104 12105 12106 12107 12108 12109 12110 12111 12112 12113 12114 12115 12116 12117 12118 12119 12120 12121 12122 12123 12124 12125 12126 12127 12128 12129 12130 12131 12132 12133 12134 12135 12136 12137 12138 12139 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12099
SWIGINTERN VALUE
_wrap_SessionIDSet_swap(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID > *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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","swap", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > &","swap", 2, argv[0] ));
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::set< FIX::SessionID > &","swap", 2, argv[0]));
}
arg2 = reinterpret_cast< std::set< FIX::SessionID > * >(argp2);
{
if(tryRubyException([&]() mutable
{
(arg1)->swap(*arg2);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
return Qnil;
fail:
return Qnil;
}
|
#to_a(*args) ⇒ Object
call-seq:
to_a -> VALUE
Convert SessionIDSet to an Array.
11326 11327 11328 11329 11330 11331 11332 11333 11334 11335 11336 11337 11338 11339 11340 11341 11342 11343 11344 11345 11346 11347 11348 11349 11350 11351 11352 11353 11354 11355 11356 11357 11358 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11326
SWIGINTERN VALUE
_wrap_SessionIDSet_to_a(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
VALUE 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","to_a", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = (VALUE)std_set_Sl_FIX_SessionID_Sg__to_a(arg1);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = result;
return vresult;
fail:
return Qnil;
}
|
#to_s(*args) ⇒ Object
call-seq:
to_s -> VALUE
Convert class to a String representation.
11369 11370 11371 11372 11373 11374 11375 11376 11377 11378 11379 11380 11381 11382 11383 11384 11385 11386 11387 11388 11389 11390 11391 11392 11393 11394 11395 11396 11397 11398 11399 11400 11401 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 11369
SWIGINTERN VALUE
_wrap_SessionIDSet_to_s(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
VALUE 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","to_s", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
{
if(tryRubyException([&]() mutable
{
result = (VALUE)std_set_Sl_FIX_SessionID_Sg__to_s(arg1);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = result;
return vresult;
fail:
return Qnil;
}
|
#upper_bound(*args) ⇒ Object
12698 12699 12700 12701 12702 12703 12704 12705 12706 12707 12708 12709 12710 12711 12712 12713 12714 12715 12716 12717 12718 12719 12720 12721 12722 12723 12724 12725 12726 12727 12728 12729 12730 12731 12732 12733 12734 12735 12736 12737 12738 12739 12740 12741 |
# File 'ext/quickfix/QuickfixRuby.cpp', line 12698
SWIGINTERN VALUE
_wrap_SessionIDSet_upper_bound(int argc, VALUE *argv, VALUE self) {
std::set< FIX::SessionID > *arg1 = (std::set< FIX::SessionID > *) 0 ;
std::set< FIX::SessionID >::key_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
std::set< FIX::SessionID >::iterator 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_std__setT_FIX__SessionID_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::set< FIX::SessionID > *","upper_bound", 1, self ));
}
arg1 = reinterpret_cast< std::set< FIX::SessionID > * >(argp1);
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::set< FIX::SessionID >::key_type const &","upper_bound", 2, argv[0] ));
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::set< FIX::SessionID >::key_type const &","upper_bound", 2, argv[0]));
}
arg2 = reinterpret_cast< std::set< FIX::SessionID >::key_type * >(argp2);
{
if(tryRubyException([&]() mutable
{
result = (arg1)->upper_bound((std::set< FIX::SessionID >::key_type const &)*arg2);
return self;
fail:
return Qnil;
}) == Qnil)
{
SWIG_fail;
}
}
vresult = SWIG_NewPointerObj((swig::make_set_nonconst_iterator<std::set< FIX::SessionID >::iterator>(result, self)), swig::Iterator::descriptor(), SWIG_POINTER_OWN);
return vresult;
fail:
return Qnil;
}
|