Add member variable support for shared_ptr

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

Examples/test-suite/li_boost_shared_ptr.i

@@ -211,6 +211,11 @@ Klass* arraytest(Klass k[]) {
 */
 
 
+// Provide overloads for Klass and KlassDerived as some language modules, eg Python, create an extra reference in
+// the marshalling if an upcast to a base class is required.
+long use_count(const SwigBoost::shared_ptr<KlassDerived>& sptr) {
+  return sptr.use_count();
+}
 long use_count(const SwigBoost::shared_ptr<Klass>& sptr) {
   return sptr.use_count();
 }

Examples/test-suite/python/li_boost_shared_ptr_runme.py

@@ -7,9 +7,9 @@ debug = False
 class li_boost_shared_ptr_runme:
   def main(self):
     if (debug):
-      System.out.println("Started")
+      print "Started"
 
-    li_boost_shared_ptr.debug_shared = debug
+    li_boost_shared_ptr.cvar.debug_shared = debug
 
     # Change loop count to run for a long time to monitor memory
     loopCount = 1 #5000
@@ -25,7 +25,7 @@ class li_boost_shared_ptr_runme:
         raise RuntimeError("shared_ptr wrapper count not zero: ", wrapper_count)
 
     if (debug):
-      System.out.println("Finished")
+      print "Finished"
 
   def runtest(self):
     # simple shared_ptr usage - created in C++
@@ -280,27 +280,172 @@ class li_boost_shared_ptr_runme:
     # //////////////////////////////// Overloading tests ////////////////////////////////////////
     # Base class
     k = li_boost_shared_ptr.Klass("me oh my")
-    self.verifyValue(li_boost_shared_ptr.overload_rawbyval(k), "rawbyval");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyval(k), "rawbyval")
-    self.verifyValue(li_boost_shared_ptr.overload_rawbyref(k), "rawbyref");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyref(k), "rawbyref")
-    self.verifyValue(li_boost_shared_ptr.overload_rawbyptr(k), "rawbyptr");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyptr(k), "rawbyptr")
-    self.verifyValue(li_boost_shared_ptr.overload_rawbyptrref(k), "rawbyptrref");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyptrref(k), "rawbyptrref")
 
-    self.verifyValue(li_boost_shared_ptr.overload_smartbyval(k), "smartbyval");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyval(k), "smartbyval")
-    self.verifyValue(li_boost_shared_ptr.overload_smartbyref(k), "smartbyref");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyref(k), "smartbyref")
-    self.verifyValue(li_boost_shared_ptr.overload_smartbyptr(k), "smartbyptr");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyptr(k), "smartbyptr")
-    self.verifyValue(li_boost_shared_ptr.overload_smartbyptrref(k), "smartbyptrref");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyptrref(k), "smartbyptrref")
 
     # Derived class
     k = li_boost_shared_ptr.KlassDerived("me oh my")
-    self.verifyValue(li_boost_shared_ptr.overload_rawbyval(k), "rawbyval");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyval(k), "rawbyval")
-    self.verifyValue(li_boost_shared_ptr.overload_rawbyref(k), "rawbyref");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyref(k), "rawbyref")
-    self.verifyValue(li_boost_shared_ptr.overload_rawbyptr(k), "rawbyptr");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyptr(k), "rawbyptr")
-    self.verifyValue(li_boost_shared_ptr.overload_rawbyptrref(k), "rawbyptrref");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyptrref(k), "rawbyptrref")
 
-    self.verifyValue(li_boost_shared_ptr.overload_smartbyval(k), "smartbyval");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyval(k), "smartbyval")
-    self.verifyValue(li_boost_shared_ptr.overload_smartbyref(k), "smartbyref");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyref(k), "smartbyref")
-    self.verifyValue(li_boost_shared_ptr.overload_smartbyptr(k), "smartbyptr");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyptr(k), "smartbyptr")
-    self.verifyValue(li_boost_shared_ptr.overload_smartbyptrref(k), "smartbyptrref");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyptrref(k), "smartbyptrref")
+
+    # //////////////////////////////// Member variables ////////////////////////////////////////
+    # smart pointer by value
+    m = li_boost_shared_ptr.MemberVariables()
+    k = li_boost_shared_ptr.Klass("smart member value")
+    m.SmartMemberValue = k
+    val = k.getValue()
+    self.verifyValue("smart member value", val)
+    self.verifyCount(2, k)
+
+    kmember = m.SmartMemberValue
+    val = kmember.getValue()
+    self.verifyValue("smart member value", val)
+    self.verifyCount(3, kmember)
+    self.verifyCount(3, k)
+
+    del m
+    self.verifyCount(2, kmember)
+    self.verifyCount(2, k)
+
+    # smart pointer by pointer
+    m = li_boost_shared_ptr.MemberVariables()
+    k = li_boost_shared_ptr.Klass("smart member pointer")
+    m.SmartMemberPointer = k
+    val = k.getValue()
+    self.verifyValue("smart member pointer", val)
+    self.verifyCount(1, k)
+
+    kmember = m.SmartMemberPointer
+    val = kmember.getValue()
+    self.verifyValue("smart member pointer", val)
+    self.verifyCount(2, kmember)
+    self.verifyCount(2, k)
+
+    del m
+    self.verifyCount(2, kmember)
+    self.verifyCount(2, k)
+
+    # smart pointer by reference
+    m = li_boost_shared_ptr.MemberVariables()
+    k = li_boost_shared_ptr.Klass("smart member reference")
+    m.SmartMemberReference = k
+    val = k.getValue()
+    self.verifyValue("smart member reference", val)
+    self.verifyCount(2, k)
+
+    kmember = m.SmartMemberReference
+    val = kmember.getValue()
+    self.verifyValue("smart member reference", val)
+    self.verifyCount(3, kmember)
+    self.verifyCount(3, k)
+
+    # The C++ reference refers to SmartMemberValue...
+    kmemberVal = m.SmartMemberValue
+    val = kmember.getValue()
+    self.verifyValue("smart member reference", val)
+    self.verifyCount(4, kmemberVal)
+    self.verifyCount(4, kmember)
+    self.verifyCount(4, k)
+
+    del m
+    self.verifyCount(3, kmemberVal)
+    self.verifyCount(3, kmember)
+    self.verifyCount(3, k)
+
+    # plain by value
+    m = li_boost_shared_ptr.MemberVariables()
+    k = li_boost_shared_ptr.Klass("plain member value")
+    m.MemberValue = k
+    val = k.getValue()
+    self.verifyValue("plain member value", val)
+    self.verifyCount(1, k)
+
+    kmember = m.MemberValue
+    val = kmember.getValue()
+    self.verifyValue("plain member value", val)
+    self.verifyCount(1, kmember)
+    self.verifyCount(1, k)
+
+    del m
+    self.verifyCount(1, kmember)
+    self.verifyCount(1, k)
+
+    # plain by pointer
+    m = li_boost_shared_ptr.MemberVariables()
+    k = li_boost_shared_ptr.Klass("plain member pointer")
+    m.MemberPointer = k
+    val = k.getValue()
+    self.verifyValue("plain member pointer", val)
+    self.verifyCount(1, k)
+
+    kmember = m.MemberPointer
+    val = kmember.getValue()
+    self.verifyValue("plain member pointer", val)
+    self.verifyCount(1, kmember)
+    self.verifyCount(1, k)
+
+    del m
+    self.verifyCount(1, kmember)
+    self.verifyCount(1, k)
+
+    # plain by reference
+    m = li_boost_shared_ptr.MemberVariables()
+    k = li_boost_shared_ptr.Klass("plain member reference")
+    m.MemberReference = k
+    val = k.getValue()
+    self.verifyValue("plain member reference", val)
+    self.verifyCount(1, k)
+
+    kmember = m.MemberReference
+    val = kmember.getValue()
+    self.verifyValue("plain member reference", val)
+    self.verifyCount(1, kmember)
+    self.verifyCount(1, k)
+
+    del m
+    self.verifyCount(1, kmember)
+    self.verifyCount(1, k)
+
+    # null member variables
+    m = li_boost_shared_ptr.MemberVariables()
+
+    # shared_ptr by value
+    k = m.SmartMemberValue
+    if (k != None):
+      raise RuntimeError("expected null")
+    m.SmartMemberValue = None
+    k = m.SmartMemberValue
+    if (k != None):
+      raise RuntimeError("expected null")
+    self.verifyCount(0, k)
+
+    # plain by value
+    try:
+      m.MemberValue = None
+      raise RuntimeError("Failed to catch null pointer")
+    except ValueError:
+      pass
+
+    # templates
+    pid = li_boost_shared_ptr.PairIntDouble(10, 20.2)
+    if (pid.baseVal1 != 20 or pid.baseVal2 != 40.4):
+      raise RuntimeError("Base values wrong")
+    if (pid.val1 != 10 or pid.val2 != 20.2):
+      raise RuntimeError("Derived Values wrong")
 
   def verifyValue(self, expected, got):
     if (expected != got):
@@ -308,8 +453,8 @@ class li_boost_shared_ptr_runme:
 
   def verifyCount(self, expected, k):
     got = li_boost_shared_ptr.use_count(k)
-    if (expected != got - 1): # less one additional reference for marshalling the object into use_count()
+    if (expected != got):
-      raise RuntimeError("verify use_count failed. Expected: ", expected, " Got: ", got - 1)
+      raise RuntimeError("verify use_count failed. Expected: ", expected, " Got: ", got)
 
 
 runme = li_boost_shared_ptr_runme()

Lib/python/boost_shared_ptr.i

@@ -7,15 +7,13 @@
 
 // destructor mods
 %feature("unref") TYPE 
-//"if (debug_shared) { cout << \"deleting use_count: \" << (*smartarg1).use_count() << \" [\" << (boost::get_deleter<SWIG_null_deleter>(*smartarg1) ? std::string(\"CANNOT BE DETERMINED SAFELY\") : ( (*smartarg1).get() ? (*smartarg1)->getValue() : std::string(\"NULL PTR\") )) << \"]\" << endl << flush; }\n"
+"if (debug_shared) { cout << \"deleting use_count: \" << (*smartarg1).use_count() << \" [\" << (boost::get_deleter<SWIG_null_deleter>(*smartarg1) ? std::string(\"CANNOT BE DETERMINED SAFELY\") : ( (*smartarg1).get() ? (*smartarg1)->getValue() : std::string(\"NULL PTR\") )) << \"]\" << endl << flush; }\n"
                                "(void)arg1; delete smartarg1;"
 
 %feature("smartptr", noblock=1) TYPE { SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > }
 
 // TODO:
 // varout varin typemaps
-// typecheck typemaps
-// convertptr_flags
 
 // plain value
 %typemap(in) CONST TYPE (void *argp, int res = 0) {
@@ -38,7 +36,7 @@
 // plain pointer
 %typemap(in) CONST TYPE * (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
   int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $disown | %convertptr_flags, &newmem);
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
   if (!SWIG_IsOK(res)) {
     %argument_fail(res, "$type", $symname, $argnum); 
   }
@@ -122,9 +120,18 @@
   if (!SWIG_IsOK(res)) {
     %argument_fail(res, "$type", $symname, $argnum); 
   }
+/*
   if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
   if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $ltype);
   $1 = &tempshared;
+*/
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
 }
 %typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >* smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
@@ -138,9 +145,13 @@
   if (!SWIG_IsOK(res)) {
     %argument_fail(res, "$type", $symname, $argnum); 
   }
-  if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
-  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $ltype);
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
-  $1 = &tempshared;
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
 }
 %typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >* smartresult = $1 && *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;