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

shared_ptr typemaps added

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@9963 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
William S Fulton 2007-10-07 00:28:11 +00:00
commit 12919429ad
7 changed files with 1465 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

382
Examples/test-suite/csharp/li_boost_shared_ptr_runme.cs Normal file
View file

@ -0,0 +1,382 @@
using System;
using li_boost_shared_ptrNamespace;
public class runme
{
// Debugging flag
public static bool debug = false;
static void Main()
{
if (debug)
Console.WriteLine("Started");
li_boost_shared_ptr.debug_shared=debug;
const int loopCount = 1;
for (int i=0; i<loopCount; i++) {
new runme().runtest();
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
if (i%100 == 0) {
// Console.WriteLine("i: {0} {1}", i, Klass.getTotal_count());
System.Threading.Thread.Sleep(10);
}
}
if (debug)
Console.WriteLine("Nearly finished");
int countdown = 100;
while (true) {
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
System.Threading.Thread.Sleep(100);
if (--countdown == 0)
break;
if (Klass.getTotal_count() == 0)
break;
else
Console.WriteLine("Count: {0}", Klass.getTotal_count());
};
if (Klass.getTotal_count() != 0)
throw new ApplicationException("Klass.total_count=" + Klass.getTotal_count());
if (debug)
Console.WriteLine("Finished");
}
private void runtest() {
// simple shared_ptr usage - created in C++
{
Klass k = new Klass("me oh my");
String val = k.getValue();
verifyValue("me oh my", val);
verifyCount(1, k);
}
// simple shared_ptr usage - not created in C++
{
Klass k = li_boost_shared_ptr.factorycreate();
String val = k.getValue();
verifyValue("factorycreate", val);
verifyCount(1, k);
}
// pass by shared_ptr
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.smartpointertest(k);
String val = kret.getValue();
verifyValue("me oh my smartpointertest", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// pass by shared_ptr pointer
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.smartpointerpointertest(k);
String val = kret.getValue();
verifyValue("me oh my smartpointerpointertest", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// pass by shared_ptr reference
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.smartpointerreftest(k);
String val = kret.getValue();
verifyValue("me oh my smartpointerreftest", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// pass by shared_ptr pointer reference
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.smartpointerpointerreftest(k);
String val = kret.getValue();
verifyValue("me oh my smartpointerpointerreftest", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// const pass by shared_ptr
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.constsmartpointertest(k);
String val = kret.getValue();
verifyValue("me oh my", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// const pass by shared_ptr pointer
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.constsmartpointerpointertest(k);
String val = kret.getValue();
verifyValue("me oh my", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// const pass by shared_ptr reference
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.constsmartpointerreftest(k);
String val = kret.getValue();
verifyValue("me oh my", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// pass by value
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.valuetest(k);
String val = kret.getValue();
verifyValue("me oh my valuetest", val);
verifyCount(1, k);
verifyCount(1, kret);
}
// pass by pointer
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.pointertest(k);
String val = kret.getValue();
verifyValue("me oh my pointertest", val);
verifyCount(1, k);
verifyCount(1, kret);
}
// pass by reference
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.reftest(k);
String val = kret.getValue();
verifyValue("me oh my reftest", val);
verifyCount(1, k);
verifyCount(1, kret);
}
// pass by pointer reference
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.pointerreftest(k);
String val = kret.getValue();
verifyValue("me oh my pointerreftest", val);
verifyCount(1, k);
verifyCount(1, kret);
}
// null tests
{
Klass k = null;
// TODO: add in const versions too
if (li_boost_shared_ptr.smartpointertest(k) != null)
throw new ApplicationException("return was not null");
if (li_boost_shared_ptr.smartpointerpointertest(k) != null)
throw new ApplicationException("return was not null");
if (li_boost_shared_ptr.smartpointerreftest(k) != null)
throw new ApplicationException("return was not null");
if (li_boost_shared_ptr.smartpointerpointerreftest(k) != null)
throw new ApplicationException("return was not null");
if (li_boost_shared_ptr.nullsmartpointerpointertest(null) != "null pointer")
throw new ApplicationException("not null smartpointer pointer");
try { li_boost_shared_ptr.valuetest(k); throw new ApplicationException("Failed to catch null pointer"); } catch (ArgumentNullException) {}
if (li_boost_shared_ptr.pointertest(k) != null)
throw new ApplicationException("return was not null");
try { li_boost_shared_ptr.reftest(k); throw new ApplicationException("Failed to catch null pointer"); } catch (ArgumentNullException) {}
}
// $owner
{
Klass k = li_boost_shared_ptr.pointerownertest();
String val = k.getValue();
verifyValue("pointerownertest", val);
verifyCount(1, k);
}
{
Klass k = li_boost_shared_ptr.smartpointerpointerownertest();
String val = k.getValue();
verifyValue("smartpointerpointerownertest", val);
verifyCount(1, k);
}
////////////////////////////////// Derived classes ////////////////////////////////////////
// derived pass by pointer
{
KlassDerived k = new KlassDerived("me oh my");
KlassDerived kret = li_boost_shared_ptr.derivedpointertest(k);
String val = kret.getValue();
verifyValue("me oh my derivedpointertest-Derived", val);
verifyCount(2, k); // includes an extra reference for the upcast
verifyCount(2, kret);
}
// Member variables
// smart pointer by value
{
MemberVariables m = new MemberVariables();
Klass k = new Klass("smart member value");
m.SmartMemberValue = k;
String val = k.getValue();
verifyValue("smart member value", val);
verifyCount(2, k);
Klass kmember = m.SmartMemberValue;
val = kmember.getValue();
verifyValue("smart member value", val);
verifyCount(3, kmember);
verifyCount(3, k);
m.Dispose();
verifyCount(2, kmember);
verifyCount(2, k);
}
// smart pointer by pointer
{
MemberVariables m = new MemberVariables();
Klass k = new Klass("smart member pointer");
m.SmartMemberPointer = k;
String val = k.getValue();
verifyValue("smart member pointer", val);
verifyCount(1, k);
Klass kmember = m.SmartMemberPointer;
val = kmember.getValue();
verifyValue("smart member pointer", val);
verifyCount(2, kmember);
verifyCount(2, k);
m.Dispose();
verifyCount(2, kmember);
verifyCount(2, k);
}
// smart pointer by reference
{
MemberVariables m = new MemberVariables();
Klass k = new Klass("smart member reference");
m.SmartMemberReference = k;
String val = k.getValue();
verifyValue("smart member reference", val);
verifyCount(2, k);
Klass kmember = m.SmartMemberReference;
val = kmember.getValue();
verifyValue("smart member reference", val);
verifyCount(3, kmember);
verifyCount(3, k);
// The C++ reference refers to SmartMemberValue...
Klass kmemberVal = m.SmartMemberValue;
val = kmember.getValue();
verifyValue("smart member reference", val);
verifyCount(4, kmemberVal);
verifyCount(4, kmember);
verifyCount(4, k);
m.Dispose();
verifyCount(3, kmember);
verifyCount(3, k);
}
// plain by value
{
MemberVariables m = new MemberVariables();
Klass k = new Klass("plain member value");
m.MemberValue = k;
String val = k.getValue();
verifyValue("plain member value", val);
verifyCount(1, k);
Klass kmember = m.MemberValue;
val = kmember.getValue();
verifyValue("plain member value", val);
verifyCount(1, kmember);
verifyCount(1, k);
m.Dispose();
verifyCount(1, kmember);
verifyCount(1, k);
}
// plain by pointer
{
MemberVariables m = new MemberVariables();
Klass k = new Klass("plain member pointer");
m.MemberPointer = k;
String val = k.getValue();
verifyValue("plain member pointer", val);
verifyCount(1, k);
Klass kmember = m.MemberPointer;
val = kmember.getValue();
verifyValue("plain member pointer", val);
verifyCount(1, kmember);
verifyCount(1, k);
m.Dispose();
verifyCount(1, kmember);
verifyCount(1, k);
}
// plain by reference
{
MemberVariables m = new MemberVariables();
Klass k = new Klass("plain member reference");
m.MemberReference = k;
String val = k.getValue();
verifyValue("plain member reference", val);
verifyCount(1, k);
Klass kmember = m.MemberReference;
val = kmember.getValue();
verifyValue("plain member reference", val);
verifyCount(1, kmember);
verifyCount(1, k);
m.Dispose();
verifyCount(1, kmember);
verifyCount(1, k);
}
// null member variables
{
MemberVariables m = new MemberVariables();
// shared_ptr by value
Klass k = m.SmartMemberValue;
if (k != null)
throw new ApplicationException("expected null");
m.SmartMemberValue = null;
k = m.SmartMemberValue;
if (k != null)
throw new ApplicationException("expected null");
verifyCount(0, k);
// plain by value
try { m.MemberValue = null; throw new ApplicationException("Failed to catch null pointer"); } catch (ArgumentNullException) {}
}
}
private void verifyValue(String expected, String got) {
if (expected != got)
throw new Exception("verify value failed. Expected: " + expected + " Got: " + got);
}
private void verifyCount(int expected, Klass k) {
int got = li_boost_shared_ptr.use_count(k);
if (expected != got)
throw new Exception("verify use_count failed. Expected: " + expected + " Got: " + got);
}
}

406
Examples/test-suite/java/li_boost_shared_ptr_runme.java Normal file
View file

@ -0,0 +1,406 @@
import li_boost_shared_ptr.*;
public class li_boost_shared_ptr_runme {
static {
try {
System.loadLibrary("li_boost_shared_ptr");
} catch (UnsatisfiedLinkError e) {
System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
System.exit(1);
}
}
// Debugging flag
public final static boolean debug = false;
public static void main(String argv[])
{
if (debug)
System.out.println("Started");
li_boost_shared_ptr.setDebug_shared(debug);
final int loopCount = 1;
for (int i=0; i<loopCount; i++) {
new li_boost_shared_ptr_runme().runtest();
System.gc();
System.runFinalization();
try {
if (i%10 == 0) {
// System.out.println("i: " + i + " " + Klass.getTotal_count());
java.lang.Thread.sleep(10);
}
} catch (java.lang.InterruptedException e) {
}
}
if (debug)
System.out.println("Nearly finished");
int countdown = 100;
while (true) {
System.gc();
System.runFinalization();
try {
java.lang.Thread.sleep(10);
} catch (java.lang.InterruptedException e) {
}
if (--countdown == 0)
break;
if (Klass.getTotal_count() == 0)
break;
};
if (Klass.getTotal_count() != 0)
throw new RuntimeException("Klass.total_count=" + Klass.getTotal_count());
if (debug)
System.out.println("Finished");
}
private void runtest() {
// simple shared_ptr usage - created in C++
{
Klass k = new Klass("me oh my");
String val = k.getValue();
verifyValue("me oh my", val);
verifyCount(1, k);
}
// simple shared_ptr usage - not created in C++
{
Klass k = li_boost_shared_ptr.factorycreate();
String val = k.getValue();
verifyValue("factorycreate", val);
verifyCount(1, k);
}
// pass by shared_ptr
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.smartpointertest(k);
String val = kret.getValue();
verifyValue("me oh my smartpointertest", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// pass by shared_ptr pointer
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.smartpointerpointertest(k);
String val = kret.getValue();
verifyValue("me oh my smartpointerpointertest", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// pass by shared_ptr reference
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.smartpointerreftest(k);
String val = kret.getValue();
verifyValue("me oh my smartpointerreftest", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// pass by shared_ptr pointer reference
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.smartpointerpointerreftest(k);
String val = kret.getValue();
verifyValue("me oh my smartpointerpointerreftest", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// const pass by shared_ptr
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.constsmartpointertest(k);
String val = kret.getValue();
verifyValue("me oh my", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// const pass by shared_ptr pointer
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.constsmartpointerpointertest(k);
String val = kret.getValue();
verifyValue("me oh my", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// const pass by shared_ptr reference
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.constsmartpointerreftest(k);
String val = kret.getValue();
verifyValue("me oh my", val);
verifyCount(2, k);
verifyCount(2, kret);
}
// pass by value
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.valuetest(k);
String val = kret.getValue();
verifyValue("me oh my valuetest", val);
verifyCount(1, k);
verifyCount(1, kret);
}
// pass by pointer
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.pointertest(k);
String val = kret.getValue();
verifyValue("me oh my pointertest", val);
verifyCount(1, k);
verifyCount(1, kret);
}
// pass by reference
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.reftest(k);
String val = kret.getValue();
verifyValue("me oh my reftest", val);
verifyCount(1, k);
verifyCount(1, kret);
}
// pass by pointer reference
{
Klass k = new Klass("me oh my");
Klass kret = li_boost_shared_ptr.pointerreftest(k);
String val = kret.getValue();
verifyValue("me oh my pointerreftest", val);
verifyCount(1, k);
verifyCount(1, kret);
}
// null tests
{
Klass k = null;
if (li_boost_shared_ptr.smartpointertest(k) != null)
throw new RuntimeException("return was not null");
if (li_boost_shared_ptr.smartpointerpointertest(k) != null)
throw new RuntimeException("return was not null");
if (li_boost_shared_ptr.smartpointerreftest(k) != null)
throw new RuntimeException("return was not null");
if (li_boost_shared_ptr.smartpointerpointerreftest(k) != null)
throw new RuntimeException("return was not null");
if (!li_boost_shared_ptr.nullsmartpointerpointertest(null).equals("null pointer"))
throw new RuntimeException("not null smartpointer pointer");
try { li_boost_shared_ptr.valuetest(k); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}
if (li_boost_shared_ptr.pointertest(k) != null)
throw new RuntimeException("return was not null");
try { li_boost_shared_ptr.reftest(k); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}
}
// $owner
{
Klass k = li_boost_shared_ptr.pointerownertest();
String val = k.getValue();
verifyValue("pointerownertest", val);
verifyCount(1, k);
}
{
Klass k = li_boost_shared_ptr.smartpointerpointerownertest();
String val = k.getValue();
verifyValue("smartpointerpointerownertest", val);
verifyCount(1, k);
}
////////////////////////////////// Derived classes ////////////////////////////////////////
// derived pass by pointer
{
KlassDerived k = new KlassDerived("me oh my");
KlassDerived kret = li_boost_shared_ptr.derivedpointertest(k);
String val = kret.getValue();
verifyValue("me oh my derivedpointertest-Derived", val);
verifyCount(2, k); // includes an extra reference for the upcast
verifyCount(2, kret);
}
// check derivedness
{
/*
KlassDerived k = new KlassDerived("me oh my");
KlassDerived kret = li_boost_shared_ptr.derivedpointertest(k);
String val = kret.getValue();
k.append("-Appended");
val = k.getValue();
verifyValue("me oh my derivedpointertest-Appended-Derived", val);
val = kret.getValue();
verifyValue("me oh my derivedpointertest-Appended-Derived", val);
// TODO: clone it
*/
}
// Member variables
// smart pointer by value
{
MemberVariables m = new MemberVariables();
Klass k = new Klass("smart member value");
m.setSmartMemberValue(k);
String val = k.getValue();
verifyValue("smart member value", val);
verifyCount(2, k);
Klass kmember = m.getSmartMemberValue();
val = kmember.getValue();
verifyValue("smart member value", val);
verifyCount(3, kmember);
verifyCount(3, k);
m.delete();
verifyCount(2, kmember);
verifyCount(2, k);
}
// smart pointer by pointer
{
MemberVariables m = new MemberVariables();
Klass k = new Klass("smart member pointer");
m.setSmartMemberPointer(k);
String val = k.getValue();
verifyValue("smart member pointer", val);
verifyCount(1, k);
Klass kmember = m.getSmartMemberPointer();
val = kmember.getValue();
verifyValue("smart member pointer", val);
verifyCount(2, kmember);
verifyCount(2, k);
m.delete();
verifyCount(2, kmember);
verifyCount(2, k);
}
// smart pointer by reference
{
MemberVariables m = new MemberVariables();
Klass k = new Klass("smart member reference");
m.setSmartMemberReference(k);
String val = k.getValue();
verifyValue("smart member reference", val);
verifyCount(2, k);
Klass kmember = m.getSmartMemberReference();
val = kmember.getValue();
verifyValue("smart member reference", val);
verifyCount(3, kmember);
verifyCount(3, k);
// The C++ reference refers to SmartMemberValue...
Klass kmemberVal = m.getSmartMemberValue();
val = kmember.getValue();
verifyValue("smart member reference", val);
verifyCount(4, kmemberVal);
verifyCount(4, kmember);
verifyCount(4, k);
m.delete();
verifyCount(3, kmemberVal);
verifyCount(3, kmember);
verifyCount(3, k);
}
// plain by value
{
MemberVariables m = new MemberVariables();
Klass k = new Klass("plain member value");
m.setMemberValue(k);
String val = k.getValue();
verifyValue("plain member value", val);
verifyCount(1, k);
Klass kmember = m.getMemberValue();
val = kmember.getValue();
verifyValue("plain member value", val);
verifyCount(1, kmember);
verifyCount(1, k);
m.delete();
verifyCount(1, kmember);
verifyCount(1, k);
}
// plain by pointer
{
MemberVariables m = new MemberVariables();
Klass k = new Klass("plain member pointer");
m.setMemberPointer(k);
String val = k.getValue();
verifyValue("plain member pointer", val);
verifyCount(1, k);
Klass kmember = m.getMemberPointer();
val = kmember.getValue();
verifyValue("plain member pointer", val);
verifyCount(1, kmember);
verifyCount(1, k);
m.delete();
verifyCount(1, kmember);
verifyCount(1, k);
}
// plain by reference
{
MemberVariables m = new MemberVariables();
Klass k = new Klass("plain member reference");
m.setMemberReference(k);
String val = k.getValue();
verifyValue("plain member reference", val);
verifyCount(1, k);
Klass kmember = m.getMemberReference();
val = kmember.getValue();
verifyValue("plain member reference", val);
verifyCount(1, kmember);
verifyCount(1, k);
m.delete();
verifyCount(1, kmember);
verifyCount(1, k);
}
// null member variables
{
MemberVariables m = new MemberVariables();
// shared_ptr by value
Klass k = m.getSmartMemberValue();
if (k != null)
throw new RuntimeException("expected null");
m.setSmartMemberValue(null);
k = m.getSmartMemberValue();
if (k != null)
throw new RuntimeException("expected null");
verifyCount(0, k);
// plain by value
try { m.setMemberValue(null); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}
}
}
private void verifyValue(String expected, String got) {
if (!expected.equals(got))
throw new RuntimeException("verify value failed. Expected: " + expected + " Got: " + got);
}
private void verifyCount(int expected, Klass k) {
int got = li_boost_shared_ptr.use_count(k);
if (expected != got)
throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);
}
}

213
Examples/test-suite/li_boost_shared_ptr.i Normal file
View file

@ -0,0 +1,213 @@
%module li_boost_shared_ptr
%{
#include "boost/shared_ptr.hpp"
%}
%include "std_string.i"
%include "boost_shared_ptr.i"
SWIG_SHARED_PTR(Klass, Space::Klass)
SWIG_SHARED_PTR_DERIVED(KlassDerived, Space::Klass, Space::KlassDerived)
// TODO:
// check const naturalvar
// const shared_ptr
// std::vector
// Add in generic %extend for the Upcast function for derived classes
// Can probably remove the pgcpp for shared_ptr, unless wrapping shared_ptr<>* shared_ptr<>& and use IntPtr instead of HandleRef for C# ???
// Put tests in a loop and monitor memory
// Remove proxy upcast method - implement %feature("shadow") ??? which replaces the shadow method
// Change GC to garbage collect until expected result with time out
// pgcpp - make it work if comments in jtype typemap
%exception {
if (debug_shared) {
cout << "++++++" << endl;
cout << "calling $name" << endl;
}
$action
if (debug_shared) {
cout << "------" << endl;
}
}
%ignore IgnoredMultipleInheritBase;
%ignore operator=;
%newobject pointerownertest();
%newobject smartpointerpointerownertest();
%inline %{
#include <iostream>
using namespace std;
static bool debug_shared = false;
namespace Space {
struct Klass {
Klass() : value("EMPTY") { if (debug_shared) cout << "Klass() [" << value << "]" << endl; increment(); }
Klass(const std::string &val) : value(val) { if (debug_shared) cout << "Klass(string) [" << value << "]" << endl; increment(); }
virtual ~Klass() { if (debug_shared) cout << "~Klass() [" << value << "]" << endl; decrement(); }
virtual std::string getValue() { return value; }
void append(const std::string &s) { value += s; }
Klass(const Klass &other) : value(other.value) { if (debug_shared) cout << "Klass(const Klass&) [" << value << "]" << endl; increment(); }
Klass &operator=(const Klass &other) { value = other.value; return *this; }
static int getTotal_count() { return total_count; }
private: // TODO: make operator= private too to test shared_ptr
// lock increment and decrement as a destructor could be called at the same time as a new object is being created
static void increment() { /*EnterCriticalSection(lock);*/ total_count++; }
static void decrement() { /*EnterCriticalSection(lock);*/ total_count--; }
static int total_count;
// static CriticalSection lock;
std::string value;
int array[1024];
};
struct IgnoredMultipleInheritBase { virtual ~IgnoredMultipleInheritBase() {} double d; double e;};
// For most compilers, this use of multiple inheritance results in different derived and base class
// pointer values ... for some more challenging tests :)
struct KlassDerived : IgnoredMultipleInheritBase, Klass {
KlassDerived() : Klass() {}
KlassDerived(const std::string &val) : Klass(val) {}
virtual ~KlassDerived() {}
virtual std::string getValue() { return Klass::getValue() + "-Derived"; }
};
KlassDerived* derivedpointertest(KlassDerived* kd) {
if (kd)
kd->append(" derivedpointertest");
return kd;
}
boost::shared_ptr<Klass> factorycreate() {
return boost::shared_ptr<Klass>(new Klass("factorycreate"));
}
// smart pointer
boost::shared_ptr<Klass> smartpointertest(boost::shared_ptr<Klass> k) {
if (k)
k->append(" smartpointertest");
return boost::shared_ptr<Klass>(k);
}
boost::shared_ptr<Klass>* smartpointerpointertest(boost::shared_ptr<Klass>* k) {
if (k && *k)
(*k)->append(" smartpointerpointertest");
return k;
}
boost::shared_ptr<Klass>& smartpointerreftest(boost::shared_ptr<Klass>& k) {
if (k)
k->append(" smartpointerreftest");
return k;
}
boost::shared_ptr<Klass>*& smartpointerpointerreftest(boost::shared_ptr<Klass>*& k) {
if (k && *k)
(*k)->append(" smartpointerpointerreftest");
return k;
}
// const
boost::shared_ptr<const Klass> constsmartpointertest(boost::shared_ptr<const Klass> k) {
return boost::shared_ptr<const Klass>(k);
}
boost::shared_ptr<const Klass>* constsmartpointerpointertest(boost::shared_ptr<const Klass>* k) {
return k;
}
boost::shared_ptr<const Klass>& constsmartpointerreftest(boost::shared_ptr<const Klass>& k) {
return k;
}
// plain pointer
Klass valuetest(Klass k) {
k.append(" valuetest");
return k;
}
Klass *pointertest(Klass *k) {
if (k)
k->append(" pointertest");
return k;
}
Klass& reftest(Klass& k) {
k.append(" reftest");
return k;
}
Klass*& pointerreftest(Klass*& k) {
k->append(" pointerreftest");
return k;
}
// null
std::string nullsmartpointerpointertest(boost::shared_ptr<Klass>* k) {
if (k && *k)
return "not null";
else if (!k)
return "null smartpointer pointer";
else if (!*k)
return "null pointer";
}
// $owner
Klass *pointerownertest() {
return new Klass("pointerownertest");
}
boost::shared_ptr<Klass>* smartpointerpointerownertest() {
return new boost::shared_ptr<Klass>(new Klass("smartpointerpointerownertest"));
}
/*
Klass* arraytest(Klass k[]) {
k[0].append(" arraytest");
return k;
}
*/
long use_count(const boost::shared_ptr<Klass>& sptr) {
return sptr.use_count();
}
const boost::shared_ptr<Klass>& ref_1() {
static boost::shared_ptr<Klass> sptr;
return sptr;
}
} // namespace Space
%}
%{
int Space::Klass::total_count = 0;
%}
// Member variables
%inline %{
struct MemberVariables {
MemberVariables() : SmartMemberPointer(&SmartMemberValue), SmartMemberReference(SmartMemberValue), MemberPointer(0), MemberReference(MemberValue) {}
boost::shared_ptr<Space::Klass> SmartMemberValue;
boost::shared_ptr<Space::Klass> * SmartMemberPointer;
boost::shared_ptr<Space::Klass> & SmartMemberReference;
Space::Klass MemberValue;
Space::Klass * MemberPointer;
Space::Klass & MemberReference;
};
%}
// Templates
%inline %{
template <class T1, class T2> struct Base {
};
typedef Base<int, double> BaseIntDouble_t;
%}
%template(BaseIntDouble) Base<int, double>;
%inline %{
template <class T1, class T2> struct Pair : Base<T1, T2> {
T1 m_t1;
T2 m_t2;
Pair(T1 t1, T2 t2) : m_t1(t1), m_t2(t2) {}
};
%}
%template(PairIntDouble) Pair<int, double>;
SWIG_SHARED_PTR(BaseIntDouble, Base<int, double>)
// Note: cannot use Base<int, double> in the macro below because of the comma in the type,
// so we use a typedef instead. Alternatively use %arg(Base<int, double>). %arg is defined in swigmacros.swg.
SWIG_SHARED_PTR_DERIVED(PairIntDouble, BaseIntDouble_t, Pair<int, double>)