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