Gecko [ 122.154.134.11 ]

Name	Size	Permission
Makefile.swig	943 B	-rw-r--r--
argcargv.i	1.19 KB	-rw-r--r--
attribute.i	34 B	-rw-r--r--
carrays.i	129 B	-rw-r--r--
cdata.i	30 B	-rw-r--r--
cmalloc.i	32 B	-rw-r--r--
cni.i	42 B	-rw-r--r--
cpointer.i	33 B	-rw-r--r--
cstring.i	32 B	-rw-r--r--
director.swg	8.15 KB	-rw-r--r--
embed.i	169 B	-rw-r--r--
exception.i	126 B	-rw-r--r--
extconf.rb	234 B	-rw-r--r--
factory.i	32 B	-rw-r--r--
file.i	639 B	-rw-r--r--
jstring.i	952 B	-rw-r--r--
progargcargv.i	770 B	-rw-r--r--
ruby.swg	2.59 KB	-rw-r--r--
rubyapi.swg	801 B	-rw-r--r--
rubyautodoc.swg	4.2 KB	-rw-r--r--
rubyclasses.swg	8.8 KB	-rw-r--r--
rubycomplex.swg	3.24 KB	-rw-r--r--
rubycontainer.swg	26.63 KB	-rw-r--r--
rubycontainer_extended.swg	3.47 KB	-rw-r--r--
rubydef.swg	42 B	-rw-r--r--
rubyerrors.swg	3.63 KB	-rw-r--r--
rubyfragments.swg	552 B	-rw-r--r--
rubyhead.swg	3.87 KB	-rw-r--r--
rubyinit.swg	39 B	-rw-r--r--
rubyiterators.swg	22.38 KB	-rw-r--r--
rubykw.swg	1.15 KB	-rw-r--r--
rubymacros.swg	456 B	-rw-r--r--
rubyopers.swg	1.81 KB	-rw-r--r--
rubyprimtypes.swg	5.25 KB	-rw-r--r--
rubyrun.swg	13.36 KB	-rw-r--r--
rubyruntime.swg	423 B	-rw-r--r--
rubystdautodoc.swg	1.7 KB	-rw-r--r--
rubystdcommon.swg	6.45 KB	-rw-r--r--
rubystdfunctors.swg	4.07 KB	-rw-r--r--
rubystrings.swg	1.62 KB	-rw-r--r--
rubytracking.swg	5.19 KB	-rw-r--r--
rubytypemaps.swg	1.76 KB	-rw-r--r--
rubyuserdir.swg	409 B	-rw-r--r--
rubywstrings.swg	2.34 KB	-rw-r--r--
std_alloc.i	27 B	-rw-r--r--
std_basic_string.i	2.58 KB	-rw-r--r--
std_char_traits.i	33 B	-rw-r--r--
std_common.i	1.05 KB	-rw-r--r--
std_complex.i	471 B	-rw-r--r--
std_container.i	60 B	-rw-r--r--
std_deque.i	732 B	-rw-r--r--
std_except.i	35 B	-rw-r--r--
std_functors.i	768 B	-rw-r--r--
std_ios.i	380 B	-rw-r--r--
std_iostream.i	227 B	-rw-r--r--
std_list.i	1.01 KB	-rw-r--r--
std_map.i	10.85 KB	-rw-r--r--
std_multimap.i	5.9 KB	-rw-r--r--
std_multiset.i	1.37 KB	-rw-r--r--
std_pair.i	5.21 KB	-rw-r--r--
std_queue.i	851 B	-rw-r--r--
std_set.i	5.82 KB	-rw-r--r--
std_sstream.i	30 B	-rw-r--r--
std_stack.i	853 B	-rw-r--r--
std_streambuf.i	31 B	-rw-r--r--
std_string.i	190 B	-rw-r--r--
std_vector.i	1.19 KB	-rw-r--r--
std_vectora.i	950 B	-rw-r--r--
std_wstring.i	65 B	-rw-r--r--
stl.i	519 B	-rw-r--r--
timeval.i	1 KB	-rw-r--r--
typemaps.i	11.21 KB	-rw-r--r--

Code Editor : rubystdcommon.swg

/* ------------------------------------------------------------
 * The Ruby classes, for C++
 * ------------------------------------------------------------ */
%include <rubyclasses.swg>

%fragment("StdTraits","header",fragment="StdTraitsCommon")
{

namespace swig {  
  /*
    Traits that provides the from method
  */
  template <class Type> struct traits_from_ptr {
    static VALUE from(Type *val, int owner = 0) {
      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
    }
  };

template <class Type> struct traits_from {
    static VALUE from(const Type& val) {
      return traits_from_ptr<Type>::from(new Type(val), 1);
    }
  };

template <class Type> struct traits_from<Type *> {
    static VALUE from(Type* val) {
      return traits_from_ptr<Type>::from(val, 0);
    }
  };

template <class Type> struct traits_from<const Type *> {
    static VALUE from(const Type* val) {
      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
    }
  };

template <class Type>
  inline VALUE from(const Type& val) {
    return traits_from<Type>::from(val);
  }

template <class Type>
  inline VALUE from_ptr(Type* val, int owner) {
    return traits_from_ptr<Type>::from(val, owner);
  }

/*
    Traits that provides the asval/as/check method
  */
  template <class Type>
  struct traits_asptr {   
    static int asptr(VALUE obj, Type **val) {
      Type *p;
      int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
      if (SWIG_IsOK(res)) {
	if (val) *val = p;
      }
      return res;
    }
  };

template <class Type>
  inline int asptr(VALUE obj, Type **vptr) {
    return traits_asptr<Type>::asptr(obj, vptr);
  }

template <class Type> 
  struct traits_asval {
    static int asval(VALUE obj, Type *val) {
      if (val) {
	Type *p = 0;
	int res = traits_asptr<Type>::asptr(obj, &p);
	if (!SWIG_IsOK(res)) return res;	
	if (p) {
	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
	  *(const_cast<noconst_type*>(val)) = *p;
	  if (SWIG_IsNewObj(res)){
	    %delete(p);
	    res = SWIG_DelNewMask(res);
	  }
	  return res;
	} else {
	  return SWIG_ERROR;
	}
      } else {
	return traits_asptr<Type>::asptr(obj, (Type **)(0));
      }
    }
  };

template <class Type> struct traits_asval<Type*> {
    static int asval(VALUE obj, Type **val) {
      if (val) {
        typedef typename noconst_traits<Type>::noconst_type noconst_type;
        noconst_type *p = 0;
        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
        if (SWIG_IsOK(res)) {
          *(const_cast<noconst_type**>(val)) = p;
	}
	return res;
      } else {
	return traits_asptr<Type>::asptr(obj, (Type **)(0));
      }
    }
  };
  
  template <class Type>
  inline int asval(VALUE obj, Type *val) {
    return traits_asval<Type>::asval(obj, val);
  }

template <class Type> 
  struct traits_as<Type, value_category> {
    static Type as(VALUE obj, bool throw_error) {
      Type v;
      int res = asval(obj, &v);
      if (!obj || !SWIG_IsOK(res)) {
	if (throw_error) throw std::invalid_argument("bad type");
	VALUE lastErr = rb_gv_get("$!");
	if (lastErr == Qnil) {
	  %type_error(swig::type_name<Type>());
	}
      }
      return v;
    }
  };

template <class Type> 
  struct traits_as<Type, pointer_category> {
    static Type as(VALUE obj, bool throw_error) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res) && v) {
	if (SWIG_IsNewObj(res)) {
	  Type r(*v);
	  %delete(v);
	  return r;
	} else {
	  return *v;
	}
      } else {
	// Uninitialized return value, no Type() constructor required.
	if (throw_error) throw std::invalid_argument("bad type");
	VALUE lastErr = rb_gv_get("$!");
	if (lastErr == Qnil) {
	  %type_error(swig::type_name<Type>());
	}
	static Type *v_def = (Type*) malloc(sizeof(Type));
	memset(v_def,0,sizeof(Type));
	return *v_def;
      }
    }
  };

template <class Type> 
  struct traits_as<Type*, pointer_category> {
    static Type* as(VALUE obj, bool throw_error) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res)) {
	return v;
      } else {
	if (throw_error) throw std::invalid_argument("bad type");
	VALUE lastErr = rb_gv_get("$!");
	if (lastErr == Qnil) {
	  %type_error(swig::type_name<Type>());
	}
	return 0;
      }
    }
  };

template <class Type>
  inline Type as(VALUE obj, bool te = false) {
    return traits_as< Type, typename traits< Type >::category >::as(obj, te);
  }

template <class Type> 
  struct traits_check<Type, value_category> {
    static bool check(VALUE obj) {
      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
      return SWIG_IsOK(res) ? true : false;
    }
  };

template <class Type> 
  struct traits_check<Type, pointer_category> {
    static bool check(VALUE obj) {
      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
      return SWIG_IsOK(res) ? true : false;
    }
  };

template <class Type>
  inline bool check(VALUE obj) {
    return traits_check<Type, typename traits<Type>::category>::check(obj);
  }
}
}

// Define GC marking template traits for a container type
%define %create_mark_traits(Type)
%{
  namespace swig {
    template <class T>
    struct mark_traits {
      typedef typename Type<T >::const_iterator const_iterator;

inline void operator()(const Type<T >& c ) const
      {
	const_iterator i = c.begin();
	const_iterator e = c.end();
	for ( ; i != e; ++i )
	  {
	    rb_gc_mark( swig::from( &(*i) ) );
	  }
      }
    };

// Partial specializations for classes that requires no GC marking
    // or a special GC marking algorithm.
    template< >
    struct mark_traits<bool> {
      inline void operator()(const Type<bool >& c ) const {}
    };

template< >
    struct mark_traits<char> {
      inline void operator()(const Type<char >& c ) const {}
    };

template< >
    struct mark_traits<int> {
      inline void operator()(const Type<int >& c ) const {}
    };

template< >
    struct mark_traits<unsigned> {
      inline void operator()(const Type<unsigned >& c ) const {}
    };

template< >
    struct mark_traits<GC_VALUE> {
      typedef Type<GC_VALUE >::const_iterator const_iterator;

inline void operator()(const Type<GC_VALUE >& c ) const {
	const_iterator i = c.begin();
	const_iterator e = c.end();
	for ( ; i != e; ++i )
	  {
	    VALUE v = *i;
	    if ( FIXNUM_P(v) || SPECIAL_CONST_P(v) || SYMBOL_P(v) ||
		 ( BUILTIN_TYPE(v) == T_NONE ) ) continue;

rb_gc_mark( v );
	  }
      }
    };

}
%}
%enddef

${this.title}

Code Editor : rubystdcommon.swg