1
2/* ------------------------------------------------------------
3 * The Ruby classes, for C++
4 * ------------------------------------------------------------ */
5%include <rubyclasses.swg>
6
7%fragment("StdTraits","header",fragment="StdTraitsCommon")
8{
9
10namespace swig {  
11  /*
12    Traits that provides the from method
13  */
14  template <class Type> struct traits_from_ptr {
15    static VALUE from(Type *val, int owner = 0) {
16      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
17    }
18  };
19
20  template <class Type> struct traits_from {
21    static VALUE from(const Type& val) {
22      return traits_from_ptr<Type>::from(new Type(val), 1);
23    }
24  };
25
26  template <class Type> struct traits_from<Type *> {
27    static VALUE from(Type* val) {
28      return traits_from_ptr<Type>::from(val, 0);
29    }
30  };
31
32  template <class Type> struct traits_from<const Type *> {
33    static VALUE from(const Type* val) {
34      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
35    }
36  };
37
38
39  template <class Type>
40  inline VALUE from(const Type& val) {
41    return traits_from<Type>::from(val);
42  }
43
44  template <class Type>
45  inline VALUE from_ptr(Type* val, int owner) {
46    return traits_from_ptr<Type>::from(val, owner);
47  }
48
49  /*
50    Traits that provides the asval/as/check method
51  */
52  template <class Type>
53  struct traits_asptr {   
54    static int asptr(VALUE obj, Type **val) {
55      Type *p;
56      int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
57      if (SWIG_IsOK(res)) {
58	if (val) *val = p;
59      }
60      return res;
61    }
62  }; 
63
64  template <class Type>
65  inline int asptr(VALUE obj, Type **vptr) {
66    return traits_asptr<Type>::asptr(obj, vptr);
67  }
68
69  template <class Type> 
70  struct traits_asval {
71    static int asval(VALUE obj, Type *val) {
72      if (val) {
73	Type *p = 0;
74	int res = traits_asptr<Type>::asptr(obj, &p);
75	if (!SWIG_IsOK(res)) return res;	
76	if (p) {
77	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
78	  *(const_cast<noconst_type*>(val)) = *p;
79	  if (SWIG_IsNewObj(res)){
80	    %delete(p);
81	    res = SWIG_DelNewMask(res);
82	  }
83	  return res;
84	} else {
85	  return SWIG_ERROR;
86	}
87      } else {
88	return traits_asptr<Type>::asptr(obj, (Type **)(0));
89      }
90    }
91  };
92
93  template <class Type> struct traits_asval<Type*> {
94    static int asval(VALUE obj, Type **val) {
95      if (val) {
96        typedef typename noconst_traits<Type>::noconst_type noconst_type;
97        noconst_type *p = 0;
98        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
99        if (SWIG_IsOK(res)) {
100          *(const_cast<noconst_type**>(val)) = p;
101	}
102	return res;
103      } else {
104	return traits_asptr<Type>::asptr(obj, (Type **)(0));
105      }
106    }
107  };
108  
109  template <class Type>
110  inline int asval(VALUE obj, Type *val) {
111    return traits_asval<Type>::asval(obj, val);
112  }
113
114  template <class Type> 
115  struct traits_as<Type, value_category> {
116    static Type as(VALUE obj, bool throw_error) {
117      Type v;
118      int res = asval(obj, &v);
119      if (!obj || !SWIG_IsOK(res)) {
120	if (throw_error) throw std::invalid_argument("bad type");
121	VALUE lastErr = rb_gv_get("$!");
122	if (lastErr == Qnil) {
123	  %type_error(swig::type_name<Type>());
124	}
125      }
126      return v;
127    }
128  };
129
130  template <class Type> 
131  struct traits_as<Type, pointer_category> {
132    static Type as(VALUE obj, bool throw_error) {
133      Type *v = 0;      
134      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
135      if (SWIG_IsOK(res) && v) {
136	if (SWIG_IsNewObj(res)) {
137	  Type r(*v);
138	  %delete(v);
139	  return r;
140	} else {
141	  return *v;
142	}
143      } else {
144	// Uninitialized return value, no Type() constructor required.
145	if (throw_error) throw std::invalid_argument("bad type");
146	VALUE lastErr = rb_gv_get("$!");
147	if (lastErr == Qnil) {
148	  %type_error(swig::type_name<Type>());
149	}
150	static Type *v_def = (Type*) malloc(sizeof(Type));
151	memset(v_def,0,sizeof(Type));
152	return *v_def;
153      }
154    }
155  };
156
157  template <class Type> 
158  struct traits_as<Type*, pointer_category> {
159    static Type* as(VALUE obj, bool throw_error) {
160      Type *v = 0;      
161      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
162      if (SWIG_IsOK(res)) {
163	return v;
164      } else {
165	if (throw_error) throw std::invalid_argument("bad type");
166	VALUE lastErr = rb_gv_get("$!");
167	if (lastErr == Qnil) {
168	  %type_error(swig::type_name<Type>());
169	}
170	return 0;
171      }
172    }
173  };
174
175  template <class Type>
176  inline Type as(VALUE obj, bool te = false) {
177    return traits_as< Type, typename traits< Type >::category >::as(obj, te);
178  }
179
180  template <class Type> 
181  struct traits_check<Type, value_category> {
182    static bool check(VALUE obj) {
183      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
184      return SWIG_IsOK(res) ? true : false;
185    }
186  };
187
188  template <class Type> 
189  struct traits_check<Type, pointer_category> {
190    static bool check(VALUE obj) {
191      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
192      return SWIG_IsOK(res) ? true : false;
193    }
194  };
195
196  template <class Type>
197  inline bool check(VALUE obj) {
198    return traits_check<Type, typename traits<Type>::category>::check(obj);
199  }
200}
201}
202
203
204// Define GC marking template traits for a container type
205%define %create_mark_traits(Type)
206%{
207  namespace swig {
208    template <class T>
209    struct mark_traits {
210      typedef typename Type<T >::const_iterator const_iterator;
211
212      inline void operator()(const Type<T >& c ) const
213      {
214	const_iterator i = c.begin();
215	const_iterator e = c.end();
216	for ( ; i != e; ++i )
217	  {
218	    rb_gc_mark( swig::from( &(*i) ) );
219	  }
220      }
221    };
222
223    // Partial specializations for classes that requires no GC marking
224    // or a special GC marking algorithm.
225    template< >
226    struct mark_traits<bool> {
227      inline void operator()(const Type<bool >& c ) const {}
228    };
229
230    template< >
231    struct mark_traits<char> {
232      inline void operator()(const Type<char >& c ) const {}
233    };
234
235    template< >
236    struct mark_traits<int> {
237      inline void operator()(const Type<int >& c ) const {}
238    };
239
240    template< >
241    struct mark_traits<unsigned> {
242      inline void operator()(const Type<unsigned >& c ) const {}
243    };
244
245    template< >
246    struct mark_traits<GC_VALUE> {
247      typedef Type<GC_VALUE >::const_iterator const_iterator;
248
249      inline void operator()(const Type<GC_VALUE >& c ) const {
250	const_iterator i = c.begin();
251	const_iterator e = c.end();
252	for ( ; i != e; ++i )
253	  {
254	    VALUE v = *i;
255	    if ( FIXNUM_P(v) || SPECIAL_CONST_P(v) || SYMBOL_P(v) ||
256		 ( BUILTIN_TYPE(v) == T_NONE ) ) continue;
257
258	    rb_gc_mark( v );
259	  }
260      }
261    };
262
263  }
264%}
265%enddef
266