/tags/rel-1.3.35/Lib/python/pystdcommon.swg

  1%fragment("StdTraits","header",fragment="StdTraitsCommon")
  2{
  3namespace swig {  
  4  /*
  5    Traits that provides the from method
  6  */
  7  template <class Type> struct traits_from_ptr {
  8    static PyObject *from(Type *val, int owner = 0) {
  9      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
 10    }
 11  };
 12
 13  template <class Type> struct traits_from {
 14    static PyObject *from(const Type& val) {
 15      return traits_from_ptr<Type>::from(new Type(val), 1);
 16    }
 17  };
 18
 19  template <class Type> struct traits_from<Type *> {
 20    static PyObject *from(Type* val) {
 21      return traits_from_ptr<Type>::from(val, 0);
 22    }
 23  };
 24
 25  template <class Type> struct traits_from<const Type *> {
 26    static PyObject *from(const Type* val) {
 27      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
 28    }
 29  };
 30
 31
 32  template <class Type>
 33  inline PyObject *from(const Type& val) {
 34    return traits_from<Type>::from(val);
 35  }
 36
 37  template <class Type>
 38  inline PyObject *from_ptr(Type* val, int owner) {
 39    return traits_from_ptr<Type>::from(val, owner);
 40  }
 41
 42  /*
 43    Traits that provides the asval/as/check method
 44  */
 45  template <class Type>
 46  struct traits_asptr {   
 47    static int asptr(PyObject *obj, Type **val) {
 48      Type *p;
 49      int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
 50      if (SWIG_IsOK(res)) {
 51	if (val) *val = p;
 52      }
 53      return res;
 54    }
 55  }; 
 56
 57  template <class Type>
 58  inline int asptr(PyObject *obj, Type **vptr) {
 59    return traits_asptr<Type>::asptr(obj, vptr);
 60  }
 61
 62  template <class Type> 
 63  struct traits_asval {
 64    static int asval(PyObject *obj, Type *val) {
 65      if (val) {
 66	Type *p = 0;
 67	int res = traits_asptr<Type>::asptr(obj, &p);
 68	if (!SWIG_IsOK(res)) return res;	
 69	if (p) {
 70	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
 71	  *(const_cast<noconst_type*>(val)) = *p;
 72	  if (SWIG_IsNewObj(res)){
 73	    %delete(p);
 74	    res = SWIG_DelNewMask(res);
 75	  }
 76	  return res;
 77	} else {
 78	  return SWIG_ERROR;
 79	}
 80      } else {
 81	return traits_asptr<Type>::asptr(obj, (Type **)(0));
 82      }
 83    }
 84  };
 85
 86  template <class Type> struct traits_asval<Type*> {
 87    static int asval(PyObject *obj, Type **val) {
 88      if (val) {
 89        typedef typename noconst_traits<Type>::noconst_type noconst_type;
 90        noconst_type *p = 0;
 91        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
 92        if (SWIG_IsOK(res)) {
 93          *(const_cast<noconst_type**>(val)) = p;
 94	}
 95	return res;
 96      } else {
 97	return traits_asptr<Type>::asptr(obj, (Type **)(0));
 98      }
 99    }
100  };
101  
102  template <class Type>
103  inline int asval(PyObject *obj, Type *val) {
104    return traits_asval<Type>::asval(obj, val);
105  }
106
107  template <class Type> 
108  struct traits_as<Type, value_category> {
109    static Type as(PyObject *obj, bool throw_error) {
110      Type v;
111      int res = asval(obj, &v);
112      if (!obj || !SWIG_IsOK(res)) {
113	if (!PyErr_Occurred()) {
114	  %type_error(swig::type_name<Type>());
115	}
116	if (throw_error) throw std::invalid_argument("bad type");
117      }
118      return v;
119    }
120  };
121
122  template <class Type> 
123  struct traits_as<Type, pointer_category> {
124    static Type as(PyObject *obj, bool throw_error) {
125      Type *v = 0;      
126      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
127      if (SWIG_IsOK(res) && v) {
128	if (SWIG_IsNewObj(res)) {
129	  Type r(*v);
130	  %delete(v);
131	  return r;
132	} else {
133	  return *v;
134	}
135      } else {
136	// Uninitialized return value, no Type() constructor required.
137	static Type *v_def = (Type*) malloc(sizeof(Type));
138	if (!PyErr_Occurred()) {
139	  %type_error(swig::type_name<Type>());
140	}
141	if (throw_error) throw std::invalid_argument("bad type");
142	memset(v_def,0,sizeof(Type));
143	return *v_def;
144      }
145    }
146  };
147
148  template <class Type> 
149  struct traits_as<Type*, pointer_category> {
150    static Type* as(PyObject *obj, bool throw_error) {
151      Type *v = 0;      
152      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
153      if (SWIG_IsOK(res)) {
154	return v;
155      } else {
156	if (!PyErr_Occurred()) {
157	  %type_error(swig::type_name<Type>());
158	}
159	if (throw_error) throw std::invalid_argument("bad type");
160	return 0;
161      }
162    }
163  };
164    
165  template <class Type>
166  inline Type as(PyObject *obj, bool te = false) {
167    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
168  }
169
170  template <class Type> 
171  struct traits_check<Type, value_category> {
172    static bool check(PyObject *obj) {
173      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
174      return SWIG_IsOK(res) ? true : false;
175    }
176  };
177
178  template <class Type> 
179  struct traits_check<Type, pointer_category> {
180    static bool check(PyObject *obj) {
181      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
182      return SWIG_IsOK(res) ? true : false;
183    }
184  };
185
186  template <class Type>
187  inline bool check(PyObject *obj) {
188    return traits_check<Type, typename traits<Type>::category>::check(obj);
189  }
190}
191}
192
193//
194// Backward compatibility
195//
196
197#ifdef SWIG_PYTHON_BACKWARD_COMP
198%{
199#include <string>
200                                                                              
201PyObject* SwigInt_FromBool(bool b) {
202    return PyInt_FromLong(b ? 1L : 0L);
203}
204double SwigNumber_Check(PyObject* o) {
205    return PyFloat_Check(o) || PyInt_Check(o) || PyLong_Check(o);
206}
207double SwigNumber_AsDouble(PyObject* o) {
208    return PyFloat_Check(o) ? PyFloat_AsDouble(o)
209        : (PyInt_Check(o) ?   double(PyInt_AsLong(o))
210                            : double(PyLong_AsLong(o)));
211}
212PyObject* SwigString_FromString(const std::string& s) {
213    return PyString_FromStringAndSize(s.data(),s.size());
214}
215std::string SwigString_AsString(PyObject* o) {
216    return std::string(PyString_AsString(o));
217}
218%}
219
220#endif
221
222
223%define %specialize_std_container(Type,Check,As,From)
224%{
225namespace swig {
226  template <>  struct traits_asval<Type > {   
227    typedef Type value_type;
228    static int asval(PyObject *obj, value_type *val) {
229      if (Check(obj)) {
230	if (val) *val = As(obj);
231	return SWIG_OK;
232      }
233      return SWIG_ERROR;
234    }
235  };
236  template <>  struct traits_from<Type > {
237    typedef Type value_type;
238    static PyObject *from(const value_type& val) {
239      return From(val);
240    }
241  };
242
243  template <> 
244  struct traits_check<Type, value_category> {
245    static int check(PyObject *obj) {
246      int res = Check(obj);
247      return obj && res ? res : 0;
248    }
249  };
250}
251%}
252%enddef
253
254
255#define specialize_std_vector(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
256#define specialize_std_list(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
257#define specialize_std_deque(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
258#define specialize_std_set(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
259#define specialize_std_multiset(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)