Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1131 lines
27 KiB

/* -----------------------------------------------------------------------------
* See the LICENSE file for information on copyright, usage and redistribution
* of SWIG, and the README file for authors - http://www.swig.org/release.html.
*
* rubycontainer.swg
*
* Ruby sequence <-> C++ container wrapper
*
* This wrapper, and its iterator, allows a general use (and reuse) of
* the the mapping between C++ and Ruby, thanks to the C++
* templates.
*
* Of course, it needs the C++ compiler to support templates, but
* since we will use this wrapper with the STL containers, that should
* be the case.
* ----------------------------------------------------------------------------- */
%{
#include <iostream>
%}
#if !defined(SWIG_NO_EXPORT_ITERATOR_METHODS)
# if !defined(SWIG_EXPORT_ITERATOR_METHODS)
# define SWIG_EXPORT_ITERATOR_METHODS SWIG_EXPORT_ITERATOR_METHODS
# endif
#endif
%include <rubyiterators.swg>
/**** The RubySequence C++ Wrap ***/
%insert(header) %{
#include <stdexcept>
%}
%include <std_except.i>
%fragment("RubySequence_Base","header")
{
%#include <functional>
namespace swig {
template < class T >
struct yield : public std::unary_function< T, bool >
{
bool
operator()( const T& v ) const
{
return RTEST( rb_yield( swig::from< T >(v) ) );
}
};
inline size_t
check_index(ptrdiff_t i, size_t size, bool insert = false) {
if ( i < 0 ) {
if ((size_t) (-i) <= size)
return (size_t) (i + size);
} else if ( (size_t) i < size ) {
return (size_t) i;
} else if (insert && ((size_t) i == size)) {
return size;
}
throw std::out_of_range("index out of range");
}
inline size_t
slice_index(ptrdiff_t i, size_t size) {
if ( i < 0 ) {
if ((size_t) (-i) <= size) {
return (size_t) (i + size);
} else {
throw std::out_of_range("index out of range");
}
} else {
return ( (size_t) i < size ) ? ((size_t) i) : size;
}
}
template <class Sequence, class Difference>
inline typename Sequence::iterator
getpos(Sequence* self, Difference i) {
typename Sequence::iterator pos = self->begin();
std::advance(pos, check_index(i,self->size()));
return pos;
}
template <class Sequence, class Difference>
inline typename Sequence::const_iterator
cgetpos(const Sequence* self, Difference i) {
typename Sequence::const_iterator pos = self->begin();
std::advance(pos, check_index(i,self->size()));
return pos;
}
template <class Sequence, class Difference>
inline Sequence*
getslice(const Sequence* self, Difference i, Difference j) {
typename Sequence::size_type size = self->size();
typename Sequence::size_type ii = swig::check_index(i, size);
typename Sequence::size_type jj = swig::slice_index(j, size);
if (jj > ii) {
typename Sequence::const_iterator vb = self->begin();
typename Sequence::const_iterator ve = self->begin();
std::advance(vb,ii);
std::advance(ve,jj);
return new Sequence(vb, ve);
} else {
return new Sequence();
}
}
template <class Sequence, class Difference, class InputSeq>
inline void
setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
typename Sequence::size_type size = self->size();
typename Sequence::size_type ii = swig::check_index(i, size, true);
typename Sequence::size_type jj = swig::slice_index(j, size);
if (jj < ii) jj = ii;
size_t ssize = jj - ii;
if (ssize <= v.size()) {
typename Sequence::iterator sb = self->begin();
typename InputSeq::const_iterator vmid = v.begin();
std::advance(sb,ii);
std::advance(vmid, jj - ii);
self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
} else {
typename Sequence::iterator sb = self->begin();
typename Sequence::iterator se = self->begin();
std::advance(sb,ii);
std::advance(se,jj);
self->erase(sb,se);
self->insert(sb, v.begin(), v.end());
}
}
template <class Sequence, class Difference>
inline void
delslice(Sequence* self, Difference i, Difference j) {
typename Sequence::size_type size = self->size();
typename Sequence::size_type ii = swig::check_index(i, size, true);
typename Sequence::size_type jj = swig::slice_index(j, size);
if (jj > ii) {
typename Sequence::iterator sb = self->begin();
typename Sequence::iterator se = self->begin();
std::advance(sb,ii);
std::advance(se,jj);
self->erase(sb,se);
}
}
}
}
%fragment("RubySequence_Cont","header",
fragment="StdTraits",
fragment="RubySequence_Base",
fragment="ConstIterator_T")
{
namespace swig
{
/**
* This class is a proxy class for references, used to return and set values
* of an element of a Ruby Array of stuff.
* It can be used by RubySequence_InputIterator to make it work with STL
* algorithms.
*
*/
template <class T>
struct RubySequence_Ref
{
RubySequence_Ref(VALUE seq, int index)
: _seq(seq), _index(index)
{
}
operator T () const
{
VALUE item = rb_ary_entry(_seq, _index );
try {
return swig::as<T>(item, true);
} catch (std::exception& e) {
char msg[1024];
sprintf(msg, "in sequence element %d ", _index);
VALUE lastErr = rb_gv_get("$!");
if ( lastErr == Qnil ) {
%type_error(swig::type_name<T>());
}
VALUE str = rb_str_new2(msg);
str = rb_str_cat2( str, e.what() );
SWIG_Ruby_ExceptionType( NULL, str );
throw;
}
}
RubySequence_Ref& operator=(const T& v)
{
rb_ary_set(_seq, _index, swig::from< T >(v));
return *this;
}
private:
VALUE _seq;
int _index;
};
/**
* This class is a proxy to return a pointer to a class, usually
* RubySequence_Ref.
* It can be used by RubySequence_InputIterator to make it work with STL
* algorithms.
*
*/
template <class T>
struct RubySequence_ArrowProxy
{
RubySequence_ArrowProxy(const T& x): m_value(x) {}
const T* operator->() const { return &m_value; }
operator const T*() const { return &m_value; }
T m_value;
};
/**
* Input Iterator. This adapator class is a random access iterator that
* allows you to use STL algorithms with a Ruby class (a Ruby Array by default).
*
*/
template <class T, class Reference = RubySequence_Ref< T > >
struct RubySequence_InputIterator
{
typedef RubySequence_InputIterator<T, Reference > self;
typedef std::random_access_iterator_tag iterator_category;
typedef Reference reference;
typedef T value_type;
typedef T* pointer;
typedef ptrdiff_t difference_type;
RubySequence_InputIterator()
{
}
RubySequence_InputIterator(VALUE seq, int index)
: _seq(seq), _index(index)
{
}
reference operator*() const
{
return reference(_seq, _index);
}
RubySequence_ArrowProxy<T>
operator->() const {
return RubySequence_ArrowProxy<T>(operator*());
}
bool operator==(const self& ri) const
{
return (_index == ri._index) && (_seq == ri._seq);
}
bool operator!=(const self& ri) const
{
return !(operator==(ri));
}
self& operator ++ ()
{
++_index;
return *this;
}
self& operator -- ()
{
--_index;
return *this;
}
self& operator += (difference_type n)
{
_index += n;
return *this;
}
self operator +(difference_type n) const
{
return self(_seq, _index + n);
}
self& operator -= (difference_type n)
{
_index -= n;
return *this;
}
self operator -(difference_type n) const
{
return self(_seq, _index - n);
}
difference_type operator - (const self& ri) const
{
return _index - ri._index;
}
bool operator < (const self& ri) const
{
return _index < ri._index;
}
reference
operator[](difference_type n) const
{
return reference(_seq, _index + n);
}
private:
VALUE _seq;
difference_type _index;
};
/**
* This adaptor class allows you to use a Ruby Array as if it was an STL
* container, giving it begin(), end(), and iterators.
*
*/
template <class T>
struct RubySequence_Cont
{
typedef RubySequence_Ref<T> reference;
typedef const RubySequence_Ref<T> const_reference;
typedef T value_type;
typedef T* pointer;
typedef int difference_type;
typedef int size_type;
typedef const pointer const_pointer;
typedef RubySequence_InputIterator<T, reference> iterator;
typedef RubySequence_InputIterator<T, const_reference> const_iterator;
RubySequence_Cont(VALUE seq) : _seq(0)
{
if (!rb_obj_is_kind_of(seq, rb_cArray)) {
throw std::invalid_argument("an Array is expected");
}
_seq = seq;
}
~RubySequence_Cont()
{
}
size_type size() const
{
return RARRAY_LEN(_seq);
}
bool empty() const
{
return size() == 0;
}
iterator begin()
{
return iterator(_seq, 0);
}
const_iterator begin() const
{
return const_iterator(_seq, 0);
}
iterator end()
{
return iterator(_seq, size());
}
const_iterator end() const
{
return const_iterator(_seq, size());
}
reference operator[](difference_type n)
{
return reference(_seq, n);
}
const_reference operator[](difference_type n) const
{
return const_reference(_seq, n);
}
bool check(bool set_err = false) const
{
int s = (int) size();
for (int i = 0; i < s; ++i) {
VALUE item = rb_ary_entry(_seq, i );
if (!swig::check<value_type>(item)) {
if (set_err) {
char msg[1024];
sprintf(msg, "in sequence element %d", i);
SWIG_Error(SWIG_RuntimeError, msg);
}
return false;
}
}
return true;
}
private:
VALUE _seq;
};
}
}
/**
* Macros used to typemap an STL iterator -> SWIGIterator conversion.
*
*/
%define %swig_sequence_iterator(Sequence...)
#if defined(SWIG_EXPORT_ITERATOR_METHODS)
%typemap(out,noblock=1,fragment="RubySequence_Cont")
const_iterator, const_reverse_iterator {
$result = SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &),
self),
swig::ConstIterator::descriptor(),SWIG_POINTER_OWN);
}
%typemap(out,noblock=1,fragment="RubySequence_Cont")
iterator, reverse_iterator {
$result = SWIG_NewPointerObj(swig::make_nonconst_iterator(%static_cast($1,const $type &),
self),
swig::Iterator::descriptor(),SWIG_POINTER_OWN);
}
%typemap(out,noblock=1,fragment="RubySequence_Cont")
std::pair<const_iterator, const_iterator> {
$result = rb_ary_new2(2);
RARRAY_PTR($result)[0] = SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &).first),
swig::ConstIterator::descriptor(),SWIG_POINTER_OWN);
RARRAY_PTR($result)[1] = SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &).second),
swig::ConstIterator::descriptor(),SWIG_POINTER_OWN);
RARRAY_LEN($result) = 2;
}
// std::map/multimap/set allow returning std::pair< iterator, iterator > from
// equal_range, but we cannot still modify the key, so the iterator is
// const.
%typemap(out,noblock=1,fragment="RubySequence_Cont")
std::pair<iterator, iterator> {
$result = rb_ary_new2(2);
RARRAY_PTR($result)[0] = SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &).first),
swig::ConstIterator::descriptor(),SWIG_POINTER_OWN);
RARRAY_PTR($result)[1] = SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &).second),
swig::ConstIterator::descriptor(),SWIG_POINTER_OWN);
RARRAY_LEN($result) = 2;
}
%typemap(in,noblock=1,fragment="RubySequence_Cont")
const_iterator(swig::ConstIterator *iter = 0, int res),
const_reverse_iterator(swig::ConstIterator *iter = 0, int res) {
res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter),
swig::ConstIterator::descriptor(), 0);
if (!SWIG_IsOK(res) || !iter) {
%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
} else {
swig::ConstIterator_T<$type > *iter_t = dynamic_cast<swig::ConstIterator_T<$type > *>(iter);
if (iter_t) {
$1 = iter_t->get_current();
} else {
%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
}
}
}
%typemap(in,noblock=1,fragment="RubySequence_Cont")
iterator(swig::Iterator *iter = 0, int res),
reverse_iterator(swig::Iterator *iter = 0, int res) {
res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
if (!SWIG_IsOK(res) || !iter) {
%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
} else {
swig::Iterator_T<$type > *iter_t = dynamic_cast<swig::Iterator_T<$type > *>(iter);
if (iter_t) {
$1 = iter_t->get_current();
} else {
%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
}
}
}
%typecheck(%checkcode(ITERATOR),noblock=1,fragment="RubySequence_Cont")
const_iterator, const_reverse_iterator {
swig::ConstIterator *iter = 0;
int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter),
swig::ConstIterator::descriptor(), 0);
$1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::ConstIterator_T<$type > *>(iter) != 0));
}
%typecheck(%checkcode(ITERATOR),noblock=1,fragment="RubySequence_Cont")
iterator, reverse_iterator {
swig::ConstIterator *iter = 0;
int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter),
swig::Iterator::descriptor(), 0);
$1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<$type > *>(iter) != 0));
}
%fragment("RubySequence_Cont");
// %newobject iterator;
// %newobject const_iterator;
// %extend {
// swig::Iterator* iterator(VALUE* RUBY_SELF) {
// return swig::make_nonconst_iterator($self->begin(), $self->begin(),
// $self->end(), *RUBY_SELF);
// }
// swig::ConstIterator* const_iterator(VALUE* RUBY_SELF) {
// return swig::make_const_iterator($self->begin(), $self->begin(),
// $self->end(), *RUBY_SELF);
// }
// }
#endif //SWIG_EXPORT_ITERATOR_METHODS
%enddef
/**** The Ruby container methods ****/
%define %swig_container_methods(Container...)
%extend {
%newobject dup;
Container* dup()
{
return new Container(*$self);
}
}
%enddef
/**
* Macro used to define common Ruby printing methods for STL container
*
*/
%define %swig_sequence_printing_methods(Sequence...)
%extend {
VALUE inspect()
{
Sequence::const_iterator i = $self->begin();
Sequence::const_iterator e = $self->end();
VALUE str = rb_str_new2( swig::type_name< Sequence >() );
str = rb_str_cat2( str, " [" );
bool comma = false;
VALUE tmp;
for ( ; i != e; ++i, comma = true )
{
if (comma) str = rb_str_cat2( str, "," );
tmp = swig::from< Sequence::value_type >( *i );
tmp = rb_inspect( tmp );
str = rb_str_buf_append( str, tmp );
}
str = rb_str_cat2( str, "]" );
return str;
}
VALUE to_a()
{
Sequence::const_iterator i = $self->begin();
Sequence::const_iterator e = $self->end();
VALUE ary = rb_ary_new2( std::distance( i, e ) );
VALUE tmp;
for ( ; i != e; ++i )
{
tmp = swig::from< Sequence::value_type >( *i );
rb_ary_push( ary, tmp );
}
return ary;
}
VALUE to_s()
{
Sequence::iterator i = $self->begin();
Sequence::iterator e = $self->end();
VALUE str = rb_str_new2( "" );
VALUE tmp;
for ( ; i != e; ++i )
{
tmp = swig::from< Sequence::value_type >( *i );
tmp = rb_obj_as_string( tmp );
str = rb_str_buf_append( str, tmp );
}
return str;
}
}
%enddef
/**
* Macro used to add common methods to all STL sequence-type containers
*
*/
%define %swig_sequence_methods_common(Sequence...)
%swig_container_methods(%arg(Sequence))
%swig_sequence_iterator(%arg(Sequence))
%swig_sequence_printing_methods(%arg(Sequence))
%fragment("RubySequence_Base");
%extend {
VALUE slice( difference_type i, difference_type j )
{
if ( j <= 0 ) return Qnil;
std::size_t len = $self->size();
if ( i < 0 ) i = len - i;
j += i;
if ( static_cast<std::size_t>(j) >= len ) j = len-1;
VALUE r = Qnil;
try {
r = swig::from< const Sequence* >( swig::getslice(self, i, j) );
}
catch( std::out_of_range )
{
}
return r;
}
Sequence* each()
{
if ( !rb_block_given_p() )
rb_raise( rb_eArgError, "no block given");
VALUE r;
Sequence::const_iterator i = self->begin();
Sequence::const_iterator e = self->end();
for ( ; i != e; ++i )
{
r = swig::from< Sequence::value_type >(*i);
rb_yield(r);
}
return self;
}
%newobject select;
Sequence* select() {
if ( !rb_block_given_p() )
rb_raise( rb_eArgError, "no block given" );
Sequence* r = new Sequence;
Sequence::const_iterator i = $self->begin();
Sequence::const_iterator e = $self->end();
for ( ; i != e; ++i )
{
VALUE v = swig::from< Sequence::value_type >(*i);
if ( RTEST( rb_yield(v) ) )
$self->insert( r->end(), *i);
}
return r;
}
%alias reject_bang "delete_if";
Sequence* reject_bang() {
if ( !rb_block_given_p() )
rb_raise( rb_eArgError, "no block given" );
Sequence::iterator i = self->begin();
Sequence::iterator e = self->end();
for ( ; i != e; )
{
VALUE r = swig::from< Sequence::value_type >(*i);
if ( RTEST( rb_yield(r) ) )
$self->erase(i++);
else
++i;
}
return self;
}
VALUE delete_at(difference_type i) {
VALUE r = Qnil;
try {
Sequence::iterator at = swig::getpos(self, i);
r = swig::from< Sequence::value_type >( *(at) );
$self->erase(at);
}
catch (std::out_of_range)
{
}
return r;
}
VALUE __delete2__(const value_type& i) {
VALUE r = Qnil;
return r;
}
}
%enddef
/**
* Macro used to add functions for back insertion of values in
* STL Sequence containers
*
*/
%define %swig_sequence_back_inserters( Sequence... )
%extend {
VALUE pop() {
if ($self->empty()) return Qnil;
Sequence::value_type x = self->back();
$self->pop_back();
return swig::from< Sequence::value_type >( x );
}
%alias push "<<";
const value_type push( const value_type& e ) {
$self->push_back( e );
return e;
}
%newobject reject;
Sequence* reject() {
if ( !rb_block_given_p() )
rb_raise( rb_eArgError, "no block given" );
Sequence* r = new Sequence;
std::remove_copy_if( $self->begin(), $self->end(),
std::back_inserter(*r),
swig::yield< Sequence::value_type >() );
return r;
}
}
%enddef
/**
* Macro used to add functions for Sequences
*
*/
%define %swig_sequence_methods(Sequence...)
%swig_sequence_methods_common(%arg(Sequence));
%swig_sequence_back_inserters(%arg(Sequence));
%extend {
VALUE at(difference_type i) const {
VALUE r = Qnil;
try {
r = swig::from< Sequence::value_type >( *(swig::cgetpos(self, i)) );
}
catch( std::out_of_range )
{
}
return r;
}
VALUE __getitem__(difference_type i, difference_type j) const {
if ( j <= 0 ) return Qnil;
std::size_t len = $self->size();
if ( i < 0 ) i = len - i;
j += i; if ( static_cast<std::size_t>(j) >= len ) j = len-1;
VALUE r = Qnil;
try {
r = swig::from< const Sequence* >( swig::getslice(self, i, j) );
}
catch( std::out_of_range )
{
}
return r;
}
VALUE __getitem__(difference_type i) const {
VALUE r = Qnil;
try {
r = swig::from< Sequence::value_type >( *(swig::cgetpos(self, i)) );
}
catch( std::out_of_range )
{
}
return r;
}
VALUE __getitem__(VALUE i) const {
if ( rb_obj_is_kind_of( i, rb_cRange ) == Qfalse )
{
rb_raise( rb_eTypeError, "not a valid index or range" );
}
VALUE r = Qnil;
static ID id_end = rb_intern("end");
static ID id_start = rb_intern("begin");
static ID id_noend = rb_intern("exclude_end?");
VALUE start = rb_funcall( i, id_start, 0 );
VALUE end = rb_funcall( i, id_end, 0 );
bool noend = ( rb_funcall( i, id_noend, 0 ) == Qtrue );
int len = $self->size();
int s = NUM2INT( start );
if ( s < 0 ) s = len + s;
else if ( s >= len ) return Qnil;
int e = NUM2INT( end );
if ( e < 0 ) e = len + e;
if ( e < s ) return Qnil; //std::swap( s, e );
if ( noend ) e -= 1;
if ( e >= len ) e = len - 1;
return swig::from< Sequence* >( swig::getslice(self, s, e+1) );
}
VALUE __setitem__(difference_type i, const value_type& x)
{
std::size_t len = $self->size();
if ( i < 0 ) i = len - i;
else if ( static_cast<std::size_t>(i) >= len )
$self->resize( i+1, x );
else
*(swig::getpos(self,i)) = x;
return swig::from< Sequence::value_type >( x );
}
VALUE __setitem__(difference_type i, difference_type j, const Sequence& v)
throw (std::invalid_argument) {
if ( j <= 0 ) return Qnil;
std::size_t len = $self->size();
if ( i < 0 ) i = len - i;
j += i;
if ( static_cast<std::size_t>(j) >= len ) {
$self->resize( j+1, *(v.begin()) );
j = len-1;
}
VALUE r = Qnil;
swig::setslice(self, i, j, v);
r = swig::from< const Sequence* >( &v );
return r;
}
}
%enddef
// ..I don't think %swig_sequence_methods_val are really used at all anymore...
%define %swig_sequence_methods_val(Sequence...)
%swig_sequence_methods_common(%arg(Sequence))
%extend {
VALUE __getitem__(difference_type i) {
VALUE r = Qnil;
try {
r = swig::from< Sequence::value_type >( *(swig::cgetpos(self, i)) );
}
catch( std::out_of_range )
{
}
return r;
}
VALUE __setitem__(difference_type i, value_type x) {
std::size_t len = $self->size();
if ( i < 0 ) i = len - i;
else if ( static_cast<std::size_t>(i) >= len )
$self->resize( i+1, x );
else *(swig::getpos(self,i)) = x;
return swig::from< Sequence::value_type >( x );
}
}
%enddef
/**
* Macro used to add functions for front insertion of
* elements in STL sequence containers that support it.
*
*/
%define %swig_sequence_front_inserters( Sequence... )
%extend {
VALUE shift()
{
if ($self->empty()) return Qnil;
Sequence::value_type x = self->front();
$self->erase( $self->begin() );
return swig::from< Sequence::value_type >( x );
}
%typemap(in) (int argc, VALUE* argv) {
$1 = argc - 1;
$2 = argv + 1;
}
Sequence* insert( difference_type pos, int argc, VALUE* argv, ... )
{
std::size_t len = $self->size();
std::size_t i = swig::check_index( pos, len, true );
Sequence::iterator start;
VALUE elem = argv[0];
int idx = 0;
try {
Sequence::value_type val = swig::as<Sequence::value_type>( elem, true );
if ( i >= len ) {
$self->resize(i-1, val);
return $self;
}
start = $self->begin();
std::advance( start, i );
$self->insert( start++, val );
for ( ++idx; idx < argc; ++idx )
{
elem = argv[idx];
val = swig::as<Sequence::value_type>( elem );
$self->insert( start++, val );
}
}
catch( std::invalid_argument )
{
rb_raise( rb_eArgError,
Ruby_Format_TypeError( "",
swig::type_name<Sequence::value_type>(),
__FUNCTION__, idx+2, elem ));
}
return $self;
}
%typemap(in) (int argc, VALUE* argv) {
$1 = argc;
$2 = argv;
}
Sequence* unshift( int argc, VALUE* argv, ... )
{
for ( int idx = argc-1; idx >= 0; --idx )
{
Sequence::iterator start = $self->begin();
VALUE elem = argv[idx];
try {
Sequence::value_type val = swig::as<Sequence::value_type>( elem, true );
$self->insert( start, val );
}
catch( std::invalid_argument )
{
rb_raise( rb_eArgError,
Ruby_Format_TypeError( "",
swig::type_name<Sequence::value_type>(),
__FUNCTION__, idx+2, elem ));
}
}
return $self;
}
}
%enddef
//
// Common fragments
//
%fragment("StdSequenceTraits","header",
fragment="StdTraits",
fragment="RubySequence_Cont")
{
namespace swig {
template <class RubySeq, class Seq>
inline void
assign(const RubySeq& rubyseq, Seq* seq) {
%#ifdef SWIG_STD_NOASSIGN_STL
typedef typename RubySeq::value_type value_type;
typename RubySeq::const_iterator it = rubyseq.begin();
for (;it != rubyseq.end(); ++it) {
seq->insert(seq->end(),(value_type)(*it));
}
%#else
seq->assign(rubyseq.begin(), rubyseq.end());
%#endif
}
template <class Seq, class T = typename Seq::value_type >
struct traits_asptr_stdseq {
typedef Seq sequence;
typedef T value_type;
static int asptr(VALUE obj, sequence **seq) {
if (rb_obj_is_kind_of(obj, rb_cArray) == Qtrue) {
try {
RubySequence_Cont<value_type> rubyseq(obj);
if (seq) {
sequence *pseq = new sequence();
assign(rubyseq, pseq);
*seq = pseq;
return SWIG_NEWOBJ;
} else {
return rubyseq.check() ? SWIG_OK : SWIG_ERROR;
}
} catch (std::exception& e) {
if (seq) {
VALUE lastErr = rb_gv_get("$!");
if (lastErr == Qnil) {
rb_raise(rb_eTypeError, e.what());
}
}
return SWIG_ERROR;
}
} else {
sequence *p;
if (SWIG_ConvertPtr(obj,(void**)&p,
swig::type_info<sequence>(),0) == SWIG_OK) {
if (seq) *seq = p;
return SWIG_OLDOBJ;
}
}
return SWIG_ERROR;
}
};
// Partial specialization for GC_VALUE's. No need to typecheck each
// element.
template< class Seq >
struct traits_asptr_stdseq< Seq, swig::GC_VALUE > {
typedef Seq sequence;
typedef swig::GC_VALUE value_type;
static int asptr(VALUE obj, sequence **seq) {
if (rb_obj_is_kind_of(obj, rb_cArray) == Qtrue) {
try {
if (seq) {
RubySequence_Cont<value_type> rubyseq(obj);
sequence *pseq = new sequence();
assign(rubyseq, pseq);
*seq = pseq;
return SWIG_NEWOBJ;
} else {
return true;
}
} catch (std::exception& e) {
if (seq) {
VALUE lastErr = rb_gv_get("$!");
if (lastErr == Qnil) {
rb_raise(rb_eTypeError, e.what());
}
}
return SWIG_ERROR;
}
} else {
sequence *p;
if (SWIG_ConvertPtr(obj,(void**)&p,
swig::type_info<sequence>(),0) == SWIG_OK) {
if (seq) *seq = p;
return SWIG_OLDOBJ;
}
}
return SWIG_ERROR;
}
};
template <class Seq, class T = typename Seq::value_type >
struct traits_from_stdseq {
typedef Seq sequence;
typedef T value_type;
typedef typename Seq::size_type size_type;
typedef typename sequence::const_iterator const_iterator;
static VALUE from(const sequence& seq) {
#ifdef SWIG_RUBY_EXTRA_NATIVE_CONTAINERS
swig_type_info *desc = swig::type_info<sequence>();
if (desc && desc->clientdata) {
return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
}
#endif
size_type size = seq.size();
if (size <= (size_type)INT_MAX) {
VALUE obj = rb_ary_new2((int)size);
int i = 0;
for (const_iterator it = seq.begin();
it != seq.end(); ++it, ++i) {
RARRAY_PTR(obj)[i] = swig::from< value_type >(*it);
}
RARRAY_LEN(obj) = size;
rb_obj_freeze(obj); // treat as immutable result
return obj;
} else {
rb_raise(rb_eRangeError,"sequence size not valid in ruby");
return Qnil;
}
}
};
}
}
%include <rubycontainer_extended.swg>