^^&&^^

Edit File: 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);
    }
  };

/*
  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