Checkin swig binaries for win, linux and Mac...

swig/Lib/typemaps/traits.swg

+//
+// Use the following macro with modern STL implementations
+//
+//#define SWIG_STD_MODERN_STL
+//
+// Use this to deactive the previous definition, when using gcc-2.95
+// or similar old compilers.
+//
+//#define SWIG_STD_NOMODERN_STL
+
+// Here, we identify compilers we now have problems with STL.
+%{
+#if defined(__GNUC__)
+#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
+#     define SWIG_STD_NOMODERN_STL
+#  endif
+#endif
+%}
+
+//
+// Common code for supporting the STD C++ namespace
+//
+
+%{
+#include <string>
+#include <stdexcept>
+%}
+
+%fragment("Traits","header") 
+{
+namespace swig {  
+  /*
+    type categories
+  */
+  struct pointer_category { };  
+  struct value_category { };
+
+  /*
+    General traits that provides type_name and type_info
+  */
+  template <class Type> struct traits { };
+
+  template <class Type>
+  inline const char* type_name() {
+    return traits<Type>::type_name();
+  }
+
+  template <class Type> 
+  struct traits_info {
+    static swig_type_info *type_query(std::string name) {
+      name += " *";
+      return SWIG_TypeQuery(name.c_str());
+    }    
+    static swig_type_info *type_info() {
+      static swig_type_info *info = type_query(type_name<Type>());
+      return info;
+    }
+  };
+
+  template <class Type>
+  inline swig_type_info *type_info() {
+    return traits_info<Type>::type_info();
+  }
+
+  /*
+    Partial specialization for pointers
+  */
+  template <class Type> struct traits <Type *> {
+    typedef pointer_category category;
+    static std::string make_ptr_name(const char* name) {
+      std::string ptrname = name;
+      ptrname += " *";
+      return ptrname;
+    }    
+    static const char* type_name() {
+      static std::string name = make_ptr_name(swig::type_name<Type>());
+      return name.c_str();
+    }
+  };
+
+ 
+  template <class Type, class Category = typename traits<Type>::category > 
+  struct traits_check { };
+
+  /*
+    Traits that provides the from method for an unknown type
+  */
+  template <int flags, class Type> struct traits_from_ptr {
+    static SWIG_Object from SWIG_FROM_DECL_ARGS(Type *val) {
+      return SWIG_NewPointerObj(val, type_info<Type>(), flags);
+    }
+  };
+
+  template <class Type> struct traits_from {
+    static SWIG_Object from SWIG_FROM_DECL_ARGS(const Type& val) {
+      return traits_from_ptr<SWIG_POINTER_OWN, Type>::from(new Type(val));
+    }
+  };
+
+  template <class Type> struct traits_from<Type *> {
+    static SWIG_Object from SWIG_FROM_DECL_ARGS(Type* val) {
+      return traits_from_ptr<0, Type>::from(val);
+    }
+  };
+
+  template <class Type>
+  inline SWIG_Object from SWIG_FROM_DECL_ARGS(const Type& val) {
+    return traits_from<Type>::from(val);
+  }
+
+  /*
+    Traits that provides the asptr/asval method for an unknown type
+  */
+  template <class Type>
+  struct traits_asptr {   
+    static int asptr SWIG_AS_DECL_ARGS (SWIG_Object obj, Type **val) {
+      Type *p;
+      int res = SWIG_ConvertPtr(obj, %as_voidptrptr(&p), type_info<Type>(), 0);
+      if (SWIG_IsOK(res) && val) *val = p;
+      return res;
+    }
+  }; 
+
+  template <class Type>
+  inline int asptr SWIG_AS_DECL_ARGS(SWIG_Object obj, Type **vptr) {
+    return traits_asptr<Type>::asptr SWIG_AS_CALL_ARGS(obj, vptr);
+  }
+
+  template <class Type> 
+  struct traits_asval {
+    static int asval SWIG_AS_DECL_ARGS(SWIG_Object obj, Type *val) {
+      if (val) {
+        Type *p = 0;
+        int res = traits_asptr<Type>::asptr SWIG_AS_CALL_ARGS(obj, &p);
+        if (SWIG_IsOK(res) && p) {
+          *val = *p;
+          if (SWIG_IsNewObj(res)) {
+            %delete(p);
+            res = SWIG_DelNewMask(res);
+          }
+        }
+        return res;
+      } else {
+        return traits_asptr<Type>::asptr SWIG_AS_CALL_ARGS(obj, (Type **)(0));
+      }
+    }
+  };
+  
+  template <class Type>
+  inline int asval SWIG_AS_DECL_ARGS (SWIG_Object obj, Type *val) {
+    return traits_asval<Type>::asval SWIG_AS_CALL_ARGS(obj, val);
+  }
+
+  /*
+    Traits that provides the check method for an unknown type
+  */
+#define SWIG_CHECK_DECL_ARGS(obj) SWIG_AS_DECL_ARGS(obj, void * = 0)
+#define SWIG_CHECK_CALL_ARGS(obj) SWIG_AS_CALL_ARGS(obj, 0)
+
+  template <class Type> 
+  struct traits_checkval {
+    static int check SWIG_CHECK_DECL_ARGS(SWIG_Object obj) {
+      if (obj) {
+        int res = asval SWIG_AS_CALL_ARGS(obj, (Type *)(0));
+        return SWIG_CheckState(res);
+      } else {
+        return 0;
+      }
+    }
+  };
+
+  template <class Type> 
+  struct traits_checkptr {
+    static int check SWIG_CHECK_DECL_ARGS(SWIG_Object obj) {
+      if (obj) {
+        int res = asptr SWIG_AS_CALL_ARGS(obj, (Type **)(0));
+        return SWIG_CheckState(res);
+      } else {
+        return 0;
+      }
+    }
+  };
+
+  template <class Type> 
+  struct traits_check<Type, value_category> : traits_checkval<Type> {
+  };
+
+  template <class Type> 
+  struct traits_check<Type, pointer_category> : traits_checkptr<Type> {
+  };
+
+  template <class Type>
+  inline int check SWIG_CHECK_DECL_ARGS(SWIG_Object obj) {
+    return traits_check<Type>::check SWIG_CHECK_CALL_ARGS(obj);
+  }
+
+}
+}
+ 
+/*
+  Generate the traits for an unknown SWIGTYPE
+*/
+
+%define %traits_swigtype(Type...)
+%fragment(SWIG_Traits_frag(Type),"header",fragment="Traits") {
+  namespace swig {
+    template <>  struct traits<Type > {
+      typedef pointer_category category;
+      static const char* type_name() { return  #Type; }
+    };
+  }
+}
+%enddef
+
+
+/*
+  Generate the traits for a 'value' type, such as 'double',
+  for which the SWIG_AsVal and SWIG_From methods are already defined.
+*/
+
+%define %traits_value(Type...)
+%fragment(SWIG_Traits_frag(Type),"header",
+          fragment=SWIG_AsVal_frag(Type),
+          fragment=SWIG_From_frag(Type),
+          fragment="Traits") {
+namespace swig {
+  template <> struct traits<Type > {
+    typedef value_category category;
+    static const char* type_name() { return  #Type; }
+  };  
+
+  template <>  struct traits_asval<Type > {   
+    typedef Type value_type;
+    static int asval SWIG_AS_DECL_ARGS (SWIG_Object obj, value_type *val) {
+      return SWIG_AsVal(Type)(obj, val);
+    }
+  };
+
+  template <>  struct traits_from<Type > {
+    typedef Type value_type;
+    static SWIG_Object from SWIG_FROM_DECL_ARGS (const value_type& val) {
+      return SWIG_From(Type)(val);
+    }
+  };
+}
+}
+%enddef
+
+/*
+  Generate the traits for a 'pointer' type, such as 'std::string',
+  for which the SWIG_AsPtr and SWIG_From methods are already defined.
+*/
+
+%define %traits_pointer(Type...)
+%fragment(SWIG_Traits_frag(Type),"header",
+          fragment=SWIG_AsVal_frag(Type),
+          fragment=SWIG_From_frag(Type),
+          fragment="Traits") {
+namespace swig {
+  template <> struct traits<Type > {
+    typedef pointer_category category;
+    static const char* type_name() { return  #Type; }
+  };  
+    
+  template <>  struct traits_asptr<Type > {   
+    typedef Type value_type;
+    static int asptr SWIG_AS_DECL_ARGS (SWIG_Object obj, value_type **val) {
+      return SWIG_AsPtr(Type)(obj, val);
+    }
+  };
+
+  template <>  struct traits_from<Type > {
+    typedef Type value_type;
+    static SWIG_Object from SWIG_FROM_DECL_ARGS (const value_type& val) {
+      return SWIG_From(Type)(val);
+    }
+  };
+}
+}
+%enddef
+
+/*
+  Generate the typemaps for a class that has 'value' traits
+*/
+
+%define %typemap_traits_value(Code,Type...)
+  %typemaps_asvalfrom(%arg(Code),
+                      %arg(swig::asval),
+                      %arg(swig::from),
+                      %arg(SWIG_Traits_frag(Type)),
+                      %arg(SWIG_Traits_frag(Type)),
+                      Type);
+%enddef
+
+/*
+  Generate the typemaps for a class that has 'pointer' traits
+*/
+
+%define %typemap_traits_pointer(Code,Type...)
+  %typemaps_asptrfrom(%arg(Code),
+                      %arg(swig::asptr),
+                      %arg(swig::from),
+                      %arg(SWIG_Traits_frag(Type)),
+                      %arg(SWIG_Traits_frag(Type)),
+                      Type);
+%enddef
+