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