| /* ----------------------------------------------------------------------------- |
| * rubyiterators.swg |
| * |
| * Implement a C++ 'output' iterator for Ruby. |
| * |
| * Users can derive form the Iterator to implemet their |
| * own iterators. As an example (real one since we use it for STL/STD |
| * containers), the template Iterator_T does the |
| * implementation for generic C++ iterators. |
| * ----------------------------------------------------------------------------- */ |
| |
| %include <std_common.i> |
| |
| |
| %fragment("ConstIterator","header",fragment="<stddef.h>",fragment="GC_VALUE_definition") { |
| namespace swig { |
| struct stop_iteration { |
| }; |
| |
| /** |
| * Abstract base class used to represent all iterators of STL containers. |
| */ |
| struct ConstIterator { |
| public: |
| typedef ConstIterator self_type; |
| |
| protected: |
| GC_VALUE _seq; |
| |
| protected: |
| ConstIterator(VALUE seq) : _seq(seq) |
| { |
| } |
| |
| // Random access iterator methods, but not required in Ruby |
| virtual ptrdiff_t distance(const ConstIterator &x) const |
| { |
| throw std::invalid_argument("distance not supported"); |
| } |
| |
| virtual bool equal (const ConstIterator &x) const |
| { |
| throw std::invalid_argument("equal not supported"); |
| } |
| |
| virtual self_type* advance(ptrdiff_t n) |
| { |
| throw std::invalid_argument("advance not supported"); |
| } |
| |
| public: |
| virtual ~ConstIterator() {} |
| |
| // Access iterator method, required by Ruby |
| virtual VALUE value() const { |
| throw std::invalid_argument("value not supported"); |
| return Qnil; |
| }; |
| |
| virtual VALUE setValue( const VALUE& v ) { |
| throw std::invalid_argument("value= not supported"); |
| return Qnil; |
| } |
| |
| virtual self_type* next( size_t n = 1 ) |
| { |
| return this->advance( n ); |
| } |
| |
| virtual self_type* previous( size_t n = 1 ) |
| { |
| ptrdiff_t nn = n; |
| return this->advance( -nn ); |
| } |
| |
| virtual VALUE to_s() const { |
| throw std::invalid_argument("to_s not supported"); |
| return Qnil; |
| } |
| |
| virtual VALUE inspect() const { |
| throw std::invalid_argument("inspect not supported"); |
| return Qnil; |
| } |
| |
| virtual ConstIterator *dup() const |
| { |
| throw std::invalid_argument("dup not supported"); |
| return NULL; |
| } |
| |
| // |
| // C++ common/needed methods. We emulate a bidirectional |
| // operator, to be compatible with all the STL. |
| // The iterator traits will then tell the STL what type of |
| // iterator we really are. |
| // |
| ConstIterator() : _seq( Qnil ) |
| { |
| } |
| |
| ConstIterator( const self_type& b ) : _seq( b._seq ) |
| { |
| } |
| |
| self_type& operator=( const self_type& b ) |
| { |
| _seq = b._seq; |
| return *this; |
| } |
| |
| bool operator == (const ConstIterator& x) const |
| { |
| return equal(x); |
| } |
| |
| bool operator != (const ConstIterator& x) const |
| { |
| return ! operator==(x); |
| } |
| |
| // Pre-decrement operator |
| self_type& operator--() |
| { |
| return *previous(); |
| } |
| |
| // Pre-increment operator |
| self_type& operator++() |
| { |
| return *next(); |
| } |
| |
| // Post-decrement operator |
| self_type operator--(int) |
| { |
| self_type r = *this; |
| previous(); |
| return r; |
| } |
| |
| // Post-increment operator |
| self_type operator++(int) |
| { |
| self_type r = *this; |
| next(); |
| return r; |
| } |
| |
| ConstIterator& operator += (ptrdiff_t n) |
| { |
| return *advance(n); |
| } |
| |
| ConstIterator& operator -= (ptrdiff_t n) |
| { |
| return *advance(-n); |
| } |
| |
| ConstIterator* operator + (ptrdiff_t n) const |
| { |
| return dup()->advance(n); |
| } |
| |
| ConstIterator* operator - (ptrdiff_t n) const |
| { |
| return dup()->advance(-n); |
| } |
| |
| ptrdiff_t operator - (const ConstIterator& x) const |
| { |
| return x.distance(*this); |
| } |
| |
| static swig_type_info* descriptor() { |
| static int init = 0; |
| static swig_type_info* desc = 0; |
| if (!init) { |
| desc = SWIG_TypeQuery("swig::ConstIterator *"); |
| init = 1; |
| } |
| return desc; |
| } |
| }; |
| |
| |
| /** |
| * Abstract base class used to represent all non-const iterators of STL containers. |
| * |
| */ |
| struct Iterator : public ConstIterator { |
| public: |
| typedef Iterator self_type; |
| |
| protected: |
| Iterator(VALUE seq) : ConstIterator(seq) |
| { |
| } |
| |
| virtual self_type* advance(ptrdiff_t n) |
| { |
| throw std::invalid_argument("operation not supported"); |
| } |
| |
| public: |
| static swig_type_info* descriptor() { |
| static int init = 0; |
| static swig_type_info* desc = 0; |
| if (!init) { |
| desc = SWIG_TypeQuery("swig::Iterator *"); |
| init = 1; |
| } |
| return desc; |
| } |
| |
| virtual Iterator *dup() const |
| { |
| throw std::invalid_argument("dup not supported"); |
| return NULL; |
| } |
| |
| virtual self_type* next( size_t n = 1 ) |
| { |
| return this->advance( n ); |
| } |
| |
| virtual self_type* previous( size_t n = 1 ) |
| { |
| ptrdiff_t nn = n; |
| return this->advance( -nn ); |
| } |
| |
| bool operator == (const ConstIterator& x) const |
| { |
| return equal(x); |
| } |
| |
| bool operator != (const Iterator& x) const |
| { |
| return ! operator==(x); |
| } |
| |
| Iterator& operator += (ptrdiff_t n) |
| { |
| return *advance(n); |
| } |
| |
| Iterator& operator -= (ptrdiff_t n) |
| { |
| return *advance(-n); |
| } |
| |
| Iterator* operator + (ptrdiff_t n) const |
| { |
| return dup()->advance(n); |
| } |
| |
| Iterator* operator - (ptrdiff_t n) const |
| { |
| return dup()->advance(-n); |
| } |
| |
| ptrdiff_t operator - (const Iterator& x) const |
| { |
| return x.distance(*this); |
| } |
| }; |
| |
| } |
| } |
| |
| |
| %fragment("ConstIterator_T","header",fragment="<stddef.h>",fragment="ConstIterator",fragment="StdTraits",fragment="StdIteratorTraits") { |
| namespace swig { |
| |
| /** |
| * Templated base classes for all custom const_iterators. |
| * |
| */ |
| template<typename OutConstIterator> |
| class ConstIterator_T : public ConstIterator |
| { |
| public: |
| typedef OutConstIterator const_iter; |
| typedef typename std::iterator_traits<const_iter>::value_type value_type; |
| typedef ConstIterator_T<const_iter> self_type; |
| |
| protected: |
| |
| |
| virtual bool equal (const ConstIterator &iter) const |
| { |
| const self_type *iters = dynamic_cast<const self_type *>(&iter); |
| if (iters) { |
| return (current == iters->get_current()); |
| } else { |
| throw std::invalid_argument("bad iterator type"); |
| } |
| } |
| |
| virtual ptrdiff_t distance(const ConstIterator &iter) const |
| { |
| const self_type *iters = dynamic_cast<const self_type *>(&iter); |
| if (iters) { |
| return std::distance(current, iters->get_current()); |
| } else { |
| throw std::invalid_argument("bad iterator type"); |
| } |
| } |
| |
| virtual ConstIterator* advance(ptrdiff_t n) |
| { |
| std::advance( current, n ); |
| return this; |
| } |
| |
| public: |
| ConstIterator_T() : ConstIterator(Qnil) |
| { |
| } |
| |
| ConstIterator_T(const_iter curr, VALUE seq = Qnil) |
| : ConstIterator(seq), current(curr) |
| { |
| } |
| |
| const const_iter& get_current() const |
| { |
| return current; |
| } |
| |
| const value_type& operator*() const |
| { |
| return *current; |
| } |
| |
| virtual VALUE inspect() const |
| { |
| VALUE ret = rb_str_new2("#<"); |
| ret = rb_str_cat2( ret, rb_obj_classname(_seq) ); |
| ret = rb_str_cat2( ret, "::const_iterator " ); |
| VALUE cur = value(); |
| ret = rb_str_concat( ret, rb_inspect(cur) ); |
| ret = rb_str_cat2( ret, ">" ); |
| return ret; |
| } |
| |
| virtual VALUE to_s() const |
| { |
| VALUE ret = rb_str_new2( rb_obj_classname(_seq) ); |
| ret = rb_str_cat2( ret, "::const_iterator " ); |
| VALUE cur = value(); |
| ret = rb_str_concat( ret, rb_obj_as_string(cur) ); |
| return ret; |
| } |
| |
| protected: |
| const_iter current; |
| }; |
| |
| |
| /** |
| * Templated base classes for all custom non-const iterators. |
| * |
| */ |
| template<typename InOutIterator> |
| class Iterator_T : public Iterator |
| { |
| public: |
| typedef InOutIterator nonconst_iter; |
| |
| // Make this class iterator STL compatible, by using iterator_traits |
| typedef typename std::iterator_traits<nonconst_iter >::iterator_category iterator_category; |
| typedef typename std::iterator_traits<nonconst_iter >::value_type value_type; |
| typedef typename std::iterator_traits<nonconst_iter >::difference_type difference_type; |
| typedef typename std::iterator_traits<nonconst_iter >::pointer pointer; |
| typedef typename std::iterator_traits<nonconst_iter >::reference reference; |
| |
| typedef Iterator base; |
| typedef Iterator_T< nonconst_iter > self_type; |
| |
| protected: |
| |
| virtual bool equal (const ConstIterator &iter) const |
| { |
| const self_type *iters = dynamic_cast<const self_type *>(&iter); |
| if (iters) { |
| return (current == iters->get_current()); |
| } else { |
| throw std::invalid_argument("bad iterator type"); |
| } |
| } |
| |
| virtual ptrdiff_t distance(const ConstIterator &iter) const |
| { |
| const self_type *iters = dynamic_cast<const self_type *>(&iter); |
| if (iters) { |
| return std::distance(current, iters->get_current()); |
| } else { |
| throw std::invalid_argument("bad iterator type"); |
| } |
| } |
| |
| virtual Iterator* advance(ptrdiff_t n) |
| { |
| std::advance( current, n ); |
| return this; |
| } |
| |
| public: |
| |
| Iterator_T(nonconst_iter curr, VALUE seq = Qnil) |
| : Iterator(seq), current(curr) |
| { |
| } |
| |
| const nonconst_iter& get_current() const |
| { |
| return current; |
| } |
| |
| self_type& operator=( const self_type& b ) |
| { |
| base::operator=( b ); |
| return *this; |
| } |
| |
| self_type& operator=( const value_type& b ) |
| { |
| *current = b; |
| return *this; |
| } |
| |
| const value_type& operator*() const |
| { |
| return *current; |
| } |
| |
| value_type& operator*() |
| { |
| return *current; |
| } |
| |
| virtual VALUE inspect() const |
| { |
| VALUE ret = rb_str_new2("#<"); |
| ret = rb_str_cat2( ret, rb_obj_classname(_seq) ); |
| ret = rb_str_cat2( ret, "::iterator " ); |
| VALUE cur = value(); |
| ret = rb_str_concat( ret, rb_inspect(cur) ); |
| ret = rb_str_cat2( ret, ">" ); |
| return ret; |
| } |
| |
| virtual VALUE to_s() const |
| { |
| VALUE ret = rb_str_new2( rb_obj_classname(_seq) ); |
| ret = rb_str_cat2( ret, "::iterator " ); |
| VALUE cur = value(); |
| ret = rb_str_concat( ret, rb_obj_as_string(cur) ); |
| return ret; |
| } |
| |
| protected: |
| nonconst_iter current; |
| }; |
| |
| |
| /** |
| * Auxiliary functor to store the value of a ruby object inside |
| * a reference of a compatible C++ type. ie: Ruby -> C++ |
| * |
| */ |
| template <class ValueType> |
| struct asval_oper |
| { |
| typedef ValueType value_type; |
| typedef bool result_type; |
| bool operator()(VALUE obj, value_type& v) const |
| { |
| return ( swig::asval< value_type >(obj, &v) == SWIG_OK ); |
| } |
| }; |
| |
| /** |
| * Auxiliary functor to return a ruby object from a C++ type. |
| * ie: C++ -> Ruby |
| * |
| */ |
| template <class ValueType> |
| struct from_oper |
| { |
| typedef const ValueType& argument_type; |
| typedef VALUE result_type; |
| result_type operator()(argument_type v) const |
| { |
| return swig::from(v); |
| } |
| }; |
| |
| |
| /** |
| * ConstIterator class for a const_iterator with no end() boundaries. |
| * |
| */ |
| template<typename OutConstIterator, |
| typename ValueType = typename std::iterator_traits<OutConstIterator>::value_type, |
| typename FromOper = from_oper<ValueType> > |
| class ConstIteratorOpen_T : public ConstIterator_T<OutConstIterator> |
| { |
| public: |
| FromOper from; |
| typedef OutConstIterator const_iter; |
| typedef ValueType value_type; |
| typedef ConstIterator_T<const_iter> base; |
| typedef ConstIteratorOpen_T<OutConstIterator, ValueType, FromOper> self_type; |
| |
| ConstIteratorOpen_T(const_iter curr, VALUE seq = Qnil) |
| : ConstIterator_T<OutConstIterator>(curr, seq) |
| { |
| } |
| |
| virtual VALUE value() const { |
| return from(static_cast<const value_type&>(*(base::current))); |
| } |
| |
| ConstIterator *dup() const |
| { |
| return new self_type(*this); |
| } |
| }; |
| |
| /** |
| * Iterator class for an iterator with no end() boundaries. |
| * |
| */ |
| template<typename InOutIterator, |
| typename ValueType = typename std::iterator_traits<InOutIterator>::value_type, |
| typename FromOper = from_oper<ValueType>, |
| typename AsvalOper = asval_oper<ValueType> > |
| class IteratorOpen_T : public Iterator_T<InOutIterator> |
| { |
| public: |
| FromOper from; |
| AsvalOper asval; |
| typedef InOutIterator nonconst_iter; |
| typedef ValueType value_type; |
| typedef Iterator_T<nonconst_iter> base; |
| typedef IteratorOpen_T<InOutIterator, ValueType, FromOper, AsvalOper> self_type; |
| |
| public: |
| IteratorOpen_T(nonconst_iter curr, VALUE seq = Qnil) |
| : Iterator_T<InOutIterator>(curr, seq) |
| { |
| } |
| |
| virtual VALUE value() const { |
| return from(static_cast<const value_type&>(*(base::current))); |
| } |
| |
| virtual VALUE setValue( const VALUE& v ) |
| { |
| value_type& dst = *base::current; |
| if ( asval(v, dst) ) return v; |
| return Qnil; |
| } |
| |
| Iterator *dup() const |
| { |
| return new self_type(*this); |
| } |
| }; |
| |
| /** |
| * ConstIterator class for a const_iterator where begin() and end() boundaries are known. |
| * |
| */ |
| template<typename OutConstIterator, |
| typename ValueType = typename std::iterator_traits<OutConstIterator>::value_type, |
| typename FromOper = from_oper<ValueType> > |
| class ConstIteratorClosed_T : public ConstIterator_T<OutConstIterator> |
| { |
| public: |
| FromOper from; |
| typedef OutConstIterator const_iter; |
| typedef ValueType value_type; |
| typedef ConstIterator_T<const_iter> base; |
| typedef ConstIteratorClosed_T<OutConstIterator, ValueType, FromOper> self_type; |
| |
| protected: |
| virtual ConstIterator* advance(ptrdiff_t n) |
| { |
| std::advance( base::current, n ); |
| if ( base::current == end ) |
| throw stop_iteration(); |
| return this; |
| } |
| |
| public: |
| ConstIteratorClosed_T(const_iter curr, const_iter first, |
| const_iter last, VALUE seq = Qnil) |
| : ConstIterator_T<OutConstIterator>(curr, seq), begin(first), end(last) |
| { |
| } |
| |
| virtual VALUE value() const { |
| if (base::current == end) { |
| throw stop_iteration(); |
| } else { |
| return from(static_cast<const value_type&>(*(base::current))); |
| } |
| } |
| |
| ConstIterator *dup() const |
| { |
| return new self_type(*this); |
| } |
| |
| |
| private: |
| const_iter begin; |
| const_iter end; |
| }; |
| |
| /** |
| * Iterator class for a iterator where begin() and end() boundaries are known. |
| * |
| */ |
| template<typename InOutIterator, |
| typename ValueType = typename std::iterator_traits<InOutIterator>::value_type, |
| typename FromOper = from_oper<ValueType>, |
| typename AsvalOper = asval_oper<ValueType> > |
| class IteratorClosed_T : public Iterator_T<InOutIterator> |
| { |
| public: |
| FromOper from; |
| AsvalOper asval; |
| typedef InOutIterator nonconst_iter; |
| typedef ValueType value_type; |
| typedef Iterator_T<nonconst_iter> base; |
| typedef IteratorClosed_T<InOutIterator, ValueType, FromOper, AsvalOper> self_type; |
| |
| protected: |
| virtual Iterator* advance(ptrdiff_t n) |
| { |
| std::advance( base::current, n ); |
| if ( base::current == end ) |
| throw stop_iteration(); |
| return this; |
| } |
| |
| public: |
| IteratorClosed_T(nonconst_iter curr, nonconst_iter first, |
| nonconst_iter last, VALUE seq = Qnil) |
| : Iterator_T<InOutIterator>(curr, seq), begin(first), end(last) |
| { |
| } |
| |
| virtual VALUE value() const { |
| if (base::current == end) { |
| throw stop_iteration(); |
| } else { |
| return from(static_cast<const value_type&>(*(base::current))); |
| } |
| } |
| |
| // Iterator setter method, required by Ruby |
| virtual VALUE setValue( const VALUE& v ) |
| { |
| if (base::current == end) |
| throw stop_iteration(); |
| |
| value_type& dst = *base::current; |
| if ( asval( v, dst ) ) return v; |
| return Qnil; |
| } |
| |
| Iterator *dup() const |
| { |
| return new self_type(*this); |
| } |
| |
| private: |
| nonconst_iter begin; |
| nonconst_iter end; |
| }; |
| |
| /* Partial specialization for bools which don't allow de-referencing */ |
| template< typename InOutIterator, typename FromOper, typename AsvalOper > |
| class IteratorOpen_T< InOutIterator, bool, FromOper, AsvalOper > : |
| public Iterator_T<InOutIterator> |
| { |
| public: |
| FromOper from; |
| AsvalOper asval; |
| typedef InOutIterator nonconst_iter; |
| typedef bool value_type; |
| typedef Iterator_T<nonconst_iter> base; |
| typedef IteratorOpen_T<InOutIterator, bool, FromOper, AsvalOper> self_type; |
| |
| IteratorOpen_T(nonconst_iter curr, VALUE seq = Qnil) |
| : Iterator_T<InOutIterator>(curr, seq) |
| { |
| } |
| |
| virtual VALUE value() const { |
| return from(static_cast<const value_type&>(*(base::current))); |
| } |
| |
| virtual VALUE setValue( const VALUE& v ) |
| { |
| bool tmp = *base::current; |
| if ( asval( v, tmp ) ) |
| { |
| *base::current = tmp; |
| return v; |
| } |
| return Qnil; |
| } |
| |
| Iterator *dup() const |
| { |
| return new self_type(*this); |
| } |
| |
| }; |
| |
| /* Partial specialization for bools which don't allow de-referencing */ |
| template< typename InOutIterator, typename FromOper, typename AsvalOper > |
| class IteratorClosed_T< InOutIterator, bool, FromOper, AsvalOper > : |
| public Iterator_T<InOutIterator> |
| { |
| public: |
| FromOper from; |
| AsvalOper asval; |
| typedef InOutIterator nonconst_iter; |
| typedef bool value_type; |
| typedef Iterator_T<nonconst_iter> base; |
| typedef IteratorClosed_T<InOutIterator, bool, FromOper, AsvalOper> self_type; |
| |
| protected: |
| virtual Iterator* advance(ptrdiff_t n) |
| { |
| std::advance( base::current, n ); |
| if ( base::current == end ) |
| throw stop_iteration(); |
| return this; |
| } |
| |
| public: |
| IteratorClosed_T(nonconst_iter curr, nonconst_iter first, |
| nonconst_iter last, VALUE seq = Qnil) |
| : Iterator_T<InOutIterator>(curr, seq), begin(first), end(last) |
| { |
| } |
| |
| virtual VALUE value() const { |
| if (base::current == end) { |
| throw stop_iteration(); |
| } else { |
| return from(static_cast<const value_type&>(*(base::current))); |
| } |
| } |
| |
| virtual VALUE setValue( const VALUE& v ) |
| { |
| if (base::current == end) |
| throw stop_iteration(); |
| |
| bool tmp = *base::current; |
| if ( asval( v, tmp ) ) |
| { |
| *base::current = tmp; |
| return v; |
| } |
| return Qnil; |
| } |
| |
| Iterator *dup() const |
| { |
| return new self_type(*this); |
| } |
| |
| private: |
| nonconst_iter begin; |
| nonconst_iter end; |
| }; |
| |
| |
| /** |
| * Helper function used to wrap a bounded const_iterator. This is to be used in |
| * a %typemap(out), for example. |
| * |
| */ |
| template<typename InOutIter> |
| inline Iterator* |
| make_nonconst_iterator(const InOutIter& current, const InOutIter& begin, |
| const InOutIter& end, VALUE seq = Qnil) |
| { |
| return new IteratorClosed_T<InOutIter>(current, begin, end, seq); |
| } |
| |
| /** |
| * Helper function used to wrap an unbounded const_iterator. This is to be used in |
| * a %typemap(out), for example. |
| * |
| */ |
| template<typename InOutIter> |
| inline Iterator* |
| make_nonconst_iterator(const InOutIter& current, VALUE seq = Qnil) |
| { |
| return new IteratorOpen_T<InOutIter>(current, seq); |
| } |
| |
| /** |
| * Helper function used to wrap a bounded const_iterator. This is to be used in |
| * a %typemap(out), for example. |
| * |
| */ |
| template<typename OutIter> |
| inline ConstIterator* |
| make_const_iterator(const OutIter& current, const OutIter& begin, |
| const OutIter& end, VALUE seq = Qnil) |
| { |
| return new ConstIteratorClosed_T<OutIter>(current, begin, end, seq); |
| } |
| |
| /** |
| * Helper function used to wrap an unbounded const_iterator. This is to be used in |
| * a %typemap(out), for example. |
| * |
| */ |
| template<typename OutIter> |
| inline ConstIterator* |
| make_const_iterator(const OutIter& current, VALUE seq = Qnil) |
| { |
| return new ConstIteratorOpen_T<OutIter>(current, seq); |
| } |
| } |
| } |
| |
| |
| %fragment("ConstIterator"); |
| |
| |
| // |
| // This part is just so SWIG is aware of the base abstract iterator class. |
| // |
| namespace swig |
| { |
| /* |
| Throw a StopIteration exception |
| */ |
| %ignore stop_iteration; |
| struct stop_iteration {}; |
| |
| %typemap(throws) stop_iteration { |
| (void)$1; |
| SWIG_Ruby_ExceptionType(NULL, Qnil); |
| SWIG_fail; |
| } |
| |
| /* |
| Mark methods that return new objects |
| */ |
| %newobject ConstIterator::dup; |
| %newobject ConstIterator::operator + (ptrdiff_t n) const; |
| %newobject ConstIterator::operator - (ptrdiff_t n) const; |
| |
| %nodirector ConstIterator; |
| |
| %catches(swig::stop_iteration) ConstIterator::value() const; |
| %catches(swig::stop_iteration) ConstIterator::incr(size_t n = 1); |
| %catches(swig::stop_iteration) ConstIterator::decr(size_t n = 1); |
| %catches(std::invalid_argument) ConstIterator::distance(const ConstIterator &x) const; |
| %catches(std::invalid_argument) ConstIterator::equal (const ConstIterator &x) const; |
| %catches(swig::stop_iteration) ConstIterator::next(); |
| %catches(swig::stop_iteration) ConstIterator::previous(); |
| %catches(swig::stop_iteration) ConstIterator::advance(ptrdiff_t n); |
| %catches(swig::stop_iteration) ConstIterator::operator += (ptrdiff_t n); |
| %catches(swig::stop_iteration) ConstIterator::operator -= (ptrdiff_t n); |
| %catches(swig::stop_iteration) ConstIterator::operator + (ptrdiff_t n) const; |
| %catches(swig::stop_iteration) ConstIterator::operator - (ptrdiff_t n) const; |
| |
| |
| struct ConstIterator |
| { |
| protected: |
| ConstIterator(VALUE seq); |
| |
| public: |
| virtual ~ConstIterator(); |
| |
| // Access iterator method, required by Ruby |
| virtual VALUE value() const; |
| |
| // C++ common/needed methods |
| virtual ConstIterator *dup() const; |
| |
| virtual VALUE inspect() const; |
| virtual VALUE to_s() const; |
| |
| virtual ConstIterator* next(size_t n = 1); |
| virtual ConstIterator* previous(size_t n = 1); |
| |
| bool operator == (const ConstIterator& x) const; |
| ConstIterator* operator + (ptrdiff_t n) const; |
| ConstIterator* operator - (ptrdiff_t n) const; |
| ptrdiff_t operator - (const ConstIterator& x) const; |
| }; |
| |
| struct Iterator : public ConstIterator |
| { |
| %rename("value=") setValue( const VALUE& v ); |
| virtual VALUE setValue( const VALUE& v ); |
| |
| virtual Iterator *dup() const; |
| |
| virtual Iterator* next(size_t n = 1); |
| virtual Iterator* previous(size_t n = 1); |
| |
| virtual VALUE inspect() const; |
| virtual VALUE to_s() const; |
| |
| bool operator == (const Iterator& x) const; |
| Iterator* operator + (ptrdiff_t n) const; |
| Iterator* operator - (ptrdiff_t n) const; |
| ptrdiff_t operator - (const Iterator& x) const; |
| }; |
| |
| } |
| |