jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix std::map and smart pointers.

Browse source 
Fixes problem with method overloading when some methods are added by %extend
and others are real methods and using template default parameters with smart pointers.
This is noticeable as a regression since 2.0.12 when using the default smart pointer
handling for some languages when the smart pointer wraps std::map and other STL containers.

Fixes SF Bug 1363
This commit is contained in:
William S Fulton 2014-03-06 19:42:57 +00:00
commit dbf44fc181
6 changed files with 70 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Examples/test-suite/common.mk
View file

@ -347,6 +347,7 @@ CPP_TEST_CASES += \
smart_pointer_simple \
smart_pointer_static \
smart_pointer_template_const_overload \
smart_pointer_template_defaults_overload \
smart_pointer_templatemethods \
smart_pointer_templatevariables \
smart_pointer_typedef \

56
Examples/test-suite/smart_pointer_template_defaults_overload.i Normal file
View file

@ -0,0 +1,56 @@
%module smart_pointer_template_defaults_overload
// SF Bug #1363
// Problem with method overloading when some methods are added by %extend and others are real methods
// and using template default parameters with smart pointers.
%warnfilter(SWIGWARN_LANG_OVERLOAD_IGNORED) Wrap::operator->;
%warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) Container::rubout;
%include <std_string.i>
%include <std_map.i>
%inline %{
template <typename T>
class Wrap {
T *ptr;
public:
Wrap(T *p) : ptr(p) {}
T const* operator->(void) const { return ptr; }
T* operator->(void) { return ptr; }
};
%}
%template(StringDoubleMap) std::map<std::string, double>; // erase is generated okay
%template(WrappedMap) Wrap< std::map<std::string, double> >; // erase wrappers lead to compile error
// Above only affects some languages depending on how std::map is implemented.
// Below is a cutdown language independent demonstration of the bug
%extend Container {
void rubout(int, int) {}
}
%inline %{
template<typename T, typename X = T> class Container {
public:
int rubout() { return 0; }
void rubout(T const &element) {}
static Container* factory() { return new Container(); }
static Container* factory(bool b) { return new Container(); }
static void staticstuff(bool) {}
#ifdef SWIG
%extend {
void rubout(bool) {}
}
#endif
};
%}
%extend Container {
void rubout(int) {}
}
%template(ContainerInt) Container<double>;
%template(WrapContainerInt) Wrap< Container<double> >;