Apply patch #3066958 from Mikael Johansson to fix default smart pointer handling when the smart pointer contains both a const and non-const operator->.

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@12240 626c5289-ae23-0410-ae9c-e8d60b6d4f22

Examples/test-suite/common.mk

@@ -294,6 +294,7 @@ CPP_TEST_CASES += \
 	sizet \
 	smart_pointer_const \
 	smart_pointer_const2 \
+	smart_pointer_const_overload \
 	smart_pointer_extend \
 	smart_pointer_member \
 	smart_pointer_multi \

Examples/test-suite/java/smart_pointer_const_overload_runme.java

@@ -0,0 +1,99 @@
+import smart_pointer_const_overload.*;
+
+public class smart_pointer_const_overload_runme {
+  static int CONST_ACCESS = 1;
+  static int MUTABLE_ACCESS = 2;
+
+  static {
+    System.loadLibrary("smart_pointer_const_overload");
+  }
+  
+  public static void test(Bar b, Foo f) {
+    Assert(f.getX() == 0);
+
+    // Test member variable get
+    Assert(b.getX() == 0);
+    Assert(f.getAccess() == CONST_ACCESS);
+
+    // Test member variable set
+    b.setX(1);
+    Assert(f.getX() == 1);
+    Assert(f.getAccess() == MUTABLE_ACCESS);
+    
+    // Test const method
+    Assert(b.getx() == 1);
+    Assert(f.getAccess() == CONST_ACCESS);
+    
+    // Test mutable method
+    b.setx(2);
+
+    Assert(f.getX() == 2);
+    Assert(f.getAccess() == MUTABLE_ACCESS);
+    
+    // Test extended const method
+    Assert(b.getx2() == 2);
+    Assert(f.getAccess() == CONST_ACCESS);
+    
+    // Test extended mutable method
+    b.setx2(3);
+
+    Assert(f.getX() == 3);
+    Assert(f.getAccess() == MUTABLE_ACCESS);
+      
+    // Test static method
+    b.stat();
+
+    Assert(f.getAccess() == CONST_ACCESS);
+
+    // Test const member
+    f.setAccess(MUTABLE_ACCESS);
+    
+    Assert(b.getY() == 0);
+    Assert(f.getAccess() == CONST_ACCESS);
+    
+    // Test get through mutable pointer to const member
+    f.setAccess(MUTABLE_ACCESS);
+    
+    Assert(smart_pointer_const_overload.get_int(b.getYp()) == 0);
+    Assert(f.getAccess() == CONST_ACCESS);
+
+    // Test get through const pointer to mutable member
+    f.setX(4);
+    f.setAccess(MUTABLE_ACCESS);
+    
+    Assert(smart_pointer_const_overload.get_int(b.getXp()) == 4);
+    Assert(f.getAccess() == CONST_ACCESS);
+      
+    // Test set through const pointer to mutable member
+    f.setAccess(MUTABLE_ACCESS);
+    smart_pointer_const_overload.set_int(b.getXp(), 5);
+    
+    Assert(f.getX() == 5);
+    Assert(f.getAccess() == CONST_ACCESS);
+  
+    // Test set pointer to const member
+    b.setYp(smart_pointer_const_overload.new_int(6));
+  
+    Assert(f.getY() == 0);
+    Assert(smart_pointer_const_overload.get_int(f.getYp()) == 6);
+    Assert(f.getAccess() == MUTABLE_ACCESS);
+  
+    smart_pointer_const_overload.delete_int(f.getYp());
+  }
+
+  public static void main(String argv[]) {
+    Foo f = new Foo();
+    Bar b = new Bar(f);
+
+    //Foo f2 = new Foo();
+    //Bar b2 = new Bar2(f2);
+
+    test(b, f);
+    //test(b2, f2);
+  }
+  
+  public static void Assert(boolean b) {
+    if (!b)
+      throw new RuntimeException("Assertion failed");
+  }
+}

Examples/test-suite/python/smart_pointer_const_overload_runme.py

@@ -0,0 +1,123 @@
+from smart_pointer_const_overload import *
+
+CONST_ACCESS = 1
+MUTABLE_ACCESS = 2
+
+def test(b, f):
+  if f.x != 0:
+    raise RuntimeError
+
+  # Test member variable get
+  if b.x != 0:
+    raise RuntimeError
+    
+  if f.access != CONST_ACCESS:
+    raise RuntimeError
+
+  # Test member variable set
+  b.x = 1
+
+  if f.x != 1:
+    raise RuntimeError
+  
+  if f.access != MUTABLE_ACCESS:
+    raise RuntimeError
+  
+  # Test const method
+  if b.getx() != 1:
+    raise RuntimeError
+  
+  if f.access != CONST_ACCESS:
+    raise RuntimeError
+  
+  # Test mutable method
+  b.setx(2)
+
+  if f.x != 2:
+    raise RuntimeError
+  
+  if f.access != MUTABLE_ACCESS:
+    raise RuntimeError
+  
+  # Test extended const method
+  if b.getx2() != 2:
+    raise RuntimeError
+  
+  if f.access != CONST_ACCESS:
+    raise RuntimeError
+  
+  # Test extended mutable method
+  b.setx2(3)
+
+  if f.x != 3:
+    raise RuntimeError
+  
+  if f.access != MUTABLE_ACCESS:
+    raise RuntimeError
+    
+  # Test static method
+  b.stat()
+
+  if f.access != CONST_ACCESS:
+    raise RuntimeError
+
+  # Test const member
+  f.access = MUTABLE_ACCESS
+  
+  if b.y != 0:
+    raise RuntimeError
+    
+  if f.access != CONST_ACCESS:
+    raise RuntimeError
+  
+  # Test get through mutable pointer to const member
+  f.access = MUTABLE_ACCESS
+  
+  if get_int(b.yp) != 0:
+    raise RuntimeError
+    
+  if f.access != CONST_ACCESS:
+    raise RuntimeError
+
+  # Test get through const pointer to mutable member
+  f.x = 4
+  f.access = MUTABLE_ACCESS
+  
+  if get_int(b.xp) != 4:
+    raise RuntimeError
+    
+  if f.access != CONST_ACCESS:
+    raise RuntimeError
+    
+  # Test set through const pointer to mutable member
+  f.access = MUTABLE_ACCESS
+  set_int(b.xp, 5)
+  
+  if f.x != 5:
+    raise RuntimeError
+  
+  if f.access != CONST_ACCESS:
+    raise RuntimeError
+
+  # Test set pointer to const member
+  b.yp = new_int(6)
+  
+  if f.y != 0:
+    raise RuntimeError
+  
+  if get_int(f.yp) != 6:
+    raise RuntimeError
+  
+  if f.access != MUTABLE_ACCESS:
+    raise RuntimeError
+    
+  delete_int(f.yp);
+
+f = Foo()
+b = Bar(f)
+
+f2 = Foo()
+b2 = Bar2(f2)
+
+test(b, f)
+test(b2, f2)

Examples/test-suite/smart_pointer_const_overload.i

@@ -0,0 +1,74 @@
+%module smart_pointer_const_overload
+
+%warnfilter(SWIGWARN_LANG_OVERLOAD_IGNORED) Bar::operator->;      // Overloaded method Bar::operator ->() ignored
+%warnfilter(SWIGWARN_LANG_OVERLOAD_IGNORED) Bar2::operator->;     // Overloaded method Bar2::operator ->() ignored
+
+%inline %{
+int CONST_ACCESS = 1;
+int MUTABLE_ACCESS = 2;
+
+int *new_int(int ivalue) {
+  int *i = (int *) malloc(sizeof(ivalue));
+  *i = ivalue;
+  return i;
+}
+
+int get_int(int *i) {
+  return *i;
+}
+
+void set_int(int *i, int ivalue) {
+  *i = ivalue;
+}
+
+void delete_int(int *i) {
+  free(i);
+}
+
+struct Foo {
+   int x;
+   int * const xp;
+   const int y;
+   const int *yp;
+   int access;
+   Foo() : x(0), xp(&x), y(0), yp(&y), access(0) { }
+   int getx() const { return x; }
+   void setx(int x_) { x = x_; }
+   static void stat() {}
+};
+%}
+
+%extend Foo {
+   int getx2() const { return self->x; }
+   void setx2(int x_) { self->x = x_; }
+};
+
+%inline %{
+class Bar {
+   Foo *f;
+public:
+   Bar(Foo *f) : f(f) { }
+   const Foo *operator->() const {
+       f->access = CONST_ACCESS;
+       return f;
+   }
+   Foo *operator->() {
+       f->access = MUTABLE_ACCESS;
+       return f;
+   }
+};
+
+class Bar2 {
+   Foo *f;
+public:
+   Bar2(Foo *f) : f(f) { }
+   Foo *operator->() {
+       f->access = MUTABLE_ACCESS;
+       return f;
+   }
+   const Foo *operator->() const {
+       f->access = CONST_ACCESS;
+       return f;
+   }
+};
+%}