// This tests intrusive_ptr is working okay. It also checks that there are no memory leaks in the | |
// class that intrusive_ptr is pointing via a counting mechanism in the constructors and destructor of Klass. | |
// In order to test that there are no leaks of the intrusive_ptr class itself (as it is created on the heap) | |
// the runtime tests can be run for a long time to monitor memory leaks using memory monitor tools | |
// like 'top'. There is a wrapper for intrusive_ptr in intrusive_ptr_wrapper.h which enables one to | |
// count the instances of intrusive_ptr. Uncomment the INTRUSIVE_PTR_WRAPPER macro to turn this on. | |
// | |
// Also note the debug_shared flag which can be set from the target language. | |
%module li_boost_intrusive_ptr | |
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK); | |
%inline %{ | |
#include "boost/shared_ptr.hpp" | |
#include "boost/intrusive_ptr.hpp" | |
#include <boost/detail/atomic_count.hpp> | |
// Uncomment macro below to turn on intrusive_ptr memory leak checking as described above | |
//#define INTRUSIVE_PTR_WRAPPER | |
#ifdef INTRUSIVE_PTR_WRAPPER | |
# include "intrusive_ptr_wrapper.h" | |
# include "shared_ptr_wrapper.h" | |
#endif | |
%} | |
%{ | |
#ifndef INTRUSIVE_PTR_WRAPPER | |
# define SwigBoost boost | |
#endif | |
%} | |
%include "std_string.i" | |
#ifndef INTRUSIVE_PTR_WRAPPER | |
# define SWIG_INTRUSIVE_PTR_NAMESPACE SwigBoost | |
# define SWIG_SHARED_PTR_NAMESPACE SwigBoost | |
#endif | |
#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) | |
#define INTRUSIVE_PTR_WRAPPERS_IMPLEMENTED | |
#endif | |
#if defined(INTRUSIVE_PTR_WRAPPERS_IMPLEMENTED) | |
%include <boost_intrusive_ptr.i> | |
%intrusive_ptr(Space::Klass) | |
%intrusive_ptr_no_wrap(Space::KlassWithoutRefCount) | |
%intrusive_ptr(Space::KlassDerived) | |
%intrusive_ptr(Space::KlassDerivedDerived) | |
//For the use_count shared_ptr functions | |
%typemap(in) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::Klass > & ($*1_ltype tempnull) %{ | |
$1 = $input ? *($&1_ltype)&$input : &tempnull; | |
%} | |
%typemap (jni) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::Klass > & "jlong" | |
%typemap (jtype) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::Klass > & "long" | |
%typemap (jstype) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::Klass > & "Klass" | |
%typemap(javain) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::Klass > & "Klass.getCPtr($javainput)" | |
%typemap(in) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::KlassDerived > & ($*1_ltype tempnull) %{ | |
$1 = $input ? *($&1_ltype)&$input : &tempnull; | |
%} | |
%typemap (jni) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::KlassDerived > & "jlong" | |
%typemap (jtype) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::KlassDerived > & "long" | |
%typemap (jstype) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::KlassDerived > & "KlassDerived" | |
%typemap(javain) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::KlassDerived > & "KlassDerived.getCPtr($javainput)" | |
%typemap(in) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::KlassDerivedDerived > & ($*1_ltype tempnull) %{ | |
$1 = $input ? *($&1_ltype)&$input : &tempnull; | |
%} | |
%typemap (jni) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::KlassDerivedDerived > & "jlong" | |
%typemap (jtype) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::KlassDerivedDerived > & "long" | |
%typemap (jstype) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::KlassDerivedDerived > & "KlassDerivedDerived" | |
%typemap(javain) SWIG_INTRUSIVE_PTR_QNAMESPACE::shared_ptr< Space::KlassDerivedDerived > & "KlassDerivedDerived.getCPtr($javainput)" | |
#endif | |
// TODO: | |
// const intrusive_ptr | |
// std::vector | |
// Add in generic %extend for the Upcast function for derived classes | |
// Remove proxy upcast method - implement %feature("shadow") ??? which replaces the proxy method | |
%exception { | |
if (debug_shared) { | |
cout << "++++++" << endl << flush; | |
cout << "calling $name" << endl << flush; | |
} | |
$action | |
if (debug_shared) { | |
cout << "------" << endl << flush; | |
} | |
} | |
%ignore IgnoredRefCountingBase; | |
%ignore *::operator=; | |
%ignore intrusive_ptr_add_ref; | |
%ignore intrusive_ptr_release; | |
%newobject pointerownertest(); | |
%newobject smartpointerpointerownertest(); | |
%inline %{ | |
#include <iostream> | |
using namespace std; | |
static bool debug_shared = false; | |
namespace Space { | |
struct Klass { | |
Klass() : value("EMPTY"), count(0) { if (debug_shared) cout << "Klass() [" << value << "]" << endl << flush; increment(); } | |
Klass(const std::string &val) : value(val), count(0) { if (debug_shared) cout << "Klass(string) [" << value << "]" << endl << flush; increment(); } | |
virtual ~Klass() { if (debug_shared) cout << "~Klass() [" << value << "]" << endl << flush; decrement(); } | |
virtual std::string getValue() const { return value; } | |
void append(const std::string &s) { value += s; } | |
Klass(const Klass &other) : value(other.value), count(0) { if (debug_shared) cout << "Klass(const Klass&) [" << value << "]" << endl << flush; increment(); } | |
Klass &operator=(const Klass &other) { value = other.value; return *this; } | |
void addref(void) const { ++count; } | |
void release(void) const { if (--count == 0) delete this; } | |
int use_count(void) const { return count; } | |
static long getTotal_count() { return total_count; } | |
private: | |
static void increment() { ++total_count; if (debug_shared) cout << " ++xxxxx Klass::increment tot: " << total_count << endl;} | |
static void decrement() { --total_count; if (debug_shared) cout << " --xxxxx Klass::decrement tot: " << total_count << endl;} | |
static boost::detail::atomic_count total_count; | |
std::string value; | |
int array[1024]; | |
mutable boost::detail::atomic_count count; | |
}; | |
struct KlassWithoutRefCount { | |
KlassWithoutRefCount() : value("EMPTY") { if (debug_shared) cout << "KlassWithoutRefCount() [" << value << "]" << endl << flush; increment(); } | |
KlassWithoutRefCount(const std::string &val) : value(val) { if (debug_shared) cout << "KlassWithoutRefCount(string) [" << value << "]" << endl << flush; increment(); } | |
virtual ~KlassWithoutRefCount() { if (debug_shared) cout << "~KlassWithoutRefCount() [" << value << "]" << endl << flush; decrement(); } | |
virtual std::string getValue() const { return value; } | |
void append(const std::string &s) { value += s; } | |
KlassWithoutRefCount(const KlassWithoutRefCount &other) : value(other.value) { if (debug_shared) cout << "KlassWithoutRefCount(const KlassWithoutRefCount&) [" << value << "]" << endl << flush; increment(); } | |
std::string getSpecialValueFromUnwrappableClass() { return "this class cannot be wrapped by intrusive_ptrs but we can still use it"; } | |
KlassWithoutRefCount &operator=(const KlassWithoutRefCount &other) { value = other.value; return *this; } | |
static long getTotal_count() { return total_count; } | |
private: | |
static void increment() { ++total_count; if (debug_shared) cout << " ++xxxxx KlassWithoutRefCount::increment tot: " << total_count << endl;} | |
static void decrement() { --total_count; if (debug_shared) cout << " --xxxxx KlassWithoutRefCount::decrement tot: " << total_count << endl;} | |
static boost::detail::atomic_count total_count; | |
std::string value; | |
int array[1024]; | |
}; | |
struct IgnoredRefCountingBase { | |
IgnoredRefCountingBase() : count(0) { if (debug_shared) cout << "IgnoredRefCountingBase()" << endl << flush; increment(); } | |
IgnoredRefCountingBase(const IgnoredRefCountingBase &other) : count(0) { if (debug_shared) cout << "IgnoredRefCountingBase(const IgnoredRefCountingBase&)" << endl << flush; increment(); } | |
IgnoredRefCountingBase &operator=(const IgnoredRefCountingBase& other) { | |
return *this; | |
} | |
virtual ~IgnoredRefCountingBase() { if (debug_shared) cout << "~IgnoredRefCountingBase()" << endl << flush; decrement(); } | |
void addref(void) const { ++count; } | |
void release(void) const { if (--count == 0) delete this; } | |
int use_count(void) const { return count; } | |
static long getTotal_count() { return total_count; } | |
private: | |
static void increment() { ++total_count; if (debug_shared) cout << " ++xxxxx IgnoredRefCountingBase::increment tot: " << total_count << endl;} | |
static void decrement() { --total_count; if (debug_shared) cout << " --xxxxx IgnoredRefCountingBase::decrement tot: " << total_count << endl;} | |
static boost::detail::atomic_count total_count; | |
double d; | |
double e; | |
mutable boost::detail::atomic_count count; | |
}; | |
long getTotal_IgnoredRefCountingBase_count() { | |
return IgnoredRefCountingBase::getTotal_count(); | |
} | |
// For most compilers, this use of multiple inheritance results in different derived and base class | |
// pointer values ... for some more challenging tests :) | |
struct KlassDerived : IgnoredRefCountingBase, KlassWithoutRefCount { | |
KlassDerived() : KlassWithoutRefCount() { if (debug_shared) cout << "KlassDerived()" << endl << flush; increment(); } | |
KlassDerived(const std::string &val) : KlassWithoutRefCount(val) { if (debug_shared) cout << "KlassDerived(string) [" << val << "]" << endl << flush; increment(); } | |
KlassDerived(const KlassDerived &other) : KlassWithoutRefCount(other) { if (debug_shared) cout << "KlassDerived(const KlassDerived&))" << endl << flush; increment(); } | |
virtual ~KlassDerived() { if (debug_shared) cout << "~KlassDerived()" << endl << flush; decrement(); } | |
virtual std::string getValue() const { return KlassWithoutRefCount::getValue() + "-Derived"; } | |
int use_count(void) const { return IgnoredRefCountingBase::use_count(); } | |
static long getTotal_count() { return total_count; } | |
private: | |
static void increment() { ++total_count; if (debug_shared) cout << " ++xxxxx KlassDerived::increment tot: " << total_count << endl;} | |
static void decrement() { --total_count; if (debug_shared) cout << " --xxxxx KlassDerived::decrement tot: " << total_count << endl;} | |
static boost::detail::atomic_count total_count; | |
}; | |
struct KlassDerivedDerived : KlassDerived { | |
KlassDerivedDerived() : KlassDerived() { if (debug_shared) cout << "KlassDerivedDerived()" << endl << flush; increment(); } | |
KlassDerivedDerived(const std::string &val) : KlassDerived(val) { if (debug_shared) cout << "KlassDerivedDerived(string) [" << val << "]" << endl << flush; increment(); } | |
KlassDerivedDerived(const KlassDerived &other) : KlassDerived(other) { if (debug_shared) cout << "KlassDerivedDerived(const KlassDerivedDerived&))" << endl << flush; increment(); } | |
virtual ~KlassDerivedDerived() { if (debug_shared) cout << "~KlassDerivedDerived()" << endl << flush; decrement(); } | |
virtual std::string getValue() const { return KlassWithoutRefCount::getValue() + "-DerivedDerived"; } | |
static long getTotal_count() { return total_count; } | |
private: | |
static void increment() { ++total_count; if (debug_shared) cout << " ++xxxxx KlassDerivedDerived::increment tot: " << total_count << endl;} | |
static void decrement() { --total_count; if (debug_shared) cout << " --xxxxx KlassDerivedDerived::decrement tot: " << total_count << endl;} | |
static boost::detail::atomic_count total_count; | |
}; | |
KlassDerived* derivedpointertest(KlassDerived* kd) { | |
if (kd) | |
kd->append(" derivedpointertest"); | |
return kd; | |
} | |
KlassDerived derivedvaluetest(KlassDerived kd) { | |
kd.append(" derivedvaluetest"); | |
return kd; | |
} | |
KlassDerived& derivedreftest(KlassDerived& kd) { | |
kd.append(" derivedreftest"); | |
return kd; | |
} | |
SwigBoost::intrusive_ptr<KlassDerived> derivedsmartptrtest(SwigBoost::intrusive_ptr<KlassDerived> kd) { | |
if (kd) | |
kd->append(" derivedsmartptrtest"); | |
return kd; | |
} | |
SwigBoost::intrusive_ptr<KlassDerived>* derivedsmartptrpointertest(SwigBoost::intrusive_ptr<KlassDerived>* kd) { | |
if (kd && *kd) | |
(*kd)->append(" derivedsmartptrpointertest"); | |
return kd; | |
} | |
SwigBoost::intrusive_ptr<KlassDerived>* derivedsmartptrreftest(SwigBoost::intrusive_ptr<KlassDerived>* kd) { | |
if (kd && *kd) | |
(*kd)->append(" derivedsmartptrreftest"); | |
return kd; | |
} | |
SwigBoost::intrusive_ptr<KlassDerived>*& derivedsmartptrpointerreftest(SwigBoost::intrusive_ptr<KlassDerived>*& kd) { | |
if (kd && *kd) | |
(*kd)->append(" derivedsmartptrpointerreftest"); | |
return kd; | |
} | |
SwigBoost::intrusive_ptr<Klass> factorycreate() { | |
return SwigBoost::intrusive_ptr<Klass>(new Klass("factorycreate")); | |
} | |
// smart pointer | |
SwigBoost::intrusive_ptr<Klass> smartpointertest(SwigBoost::intrusive_ptr<Klass> k) { | |
if (k) | |
k->append(" smartpointertest"); | |
return SwigBoost::intrusive_ptr<Klass>(k); | |
} | |
SwigBoost::intrusive_ptr<Klass>* smartpointerpointertest(SwigBoost::intrusive_ptr<Klass>* k) { | |
if (k && *k) | |
(*k)->append(" smartpointerpointertest"); | |
return k; | |
} | |
SwigBoost::intrusive_ptr<Klass>& smartpointerreftest(SwigBoost::intrusive_ptr<Klass>& k) { | |
if (k) | |
k->append(" smartpointerreftest"); | |
return k; | |
} | |
SwigBoost::intrusive_ptr<Klass>*& smartpointerpointerreftest(SwigBoost::intrusive_ptr<Klass>*& k) { | |
if (k && *k) | |
(*k)->append(" smartpointerpointerreftest"); | |
return k; | |
} | |
// const | |
SwigBoost::intrusive_ptr<const Klass> constsmartpointertest(SwigBoost::intrusive_ptr<const Klass> k) { | |
return SwigBoost::intrusive_ptr<const Klass>(k); | |
} | |
SwigBoost::intrusive_ptr<const Klass>* constsmartpointerpointertest(SwigBoost::intrusive_ptr<const Klass>* k) { | |
return k; | |
} | |
SwigBoost::intrusive_ptr<const Klass>& constsmartpointerreftest(SwigBoost::intrusive_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 *const& pointerreftest(Klass *const& k) { | |
k->append(" pointerreftest"); | |
return k; | |
} | |
// null | |
std::string nullsmartpointerpointertest(SwigBoost::intrusive_ptr<Klass>* k) { | |
if (k && *k) | |
return "not null"; | |
else if (!k) | |
return "null smartpointer pointer"; | |
else if (!*k) | |
return "null pointer"; | |
else | |
return "also not null"; | |
} | |
// $owner | |
Klass *pointerownertest() { | |
return new Klass("pointerownertest"); | |
} | |
SwigBoost::intrusive_ptr<Klass>* smartpointerpointerownertest() { | |
return new SwigBoost::intrusive_ptr<Klass>(new Klass("smartpointerpointerownertest")); | |
} | |
const SwigBoost::intrusive_ptr<Klass>& ref_1() { | |
static SwigBoost::intrusive_ptr<Klass> sptr; | |
return sptr; | |
} | |
// overloading tests | |
std::string overload_rawbyval(int i) { return "int"; } | |
std::string overload_rawbyval(Klass k) { return "rawbyval"; } | |
std::string overload_rawbyref(int i) { return "int"; } | |
std::string overload_rawbyref(Klass &k) { return "rawbyref"; } | |
std::string overload_rawbyptr(int i) { return "int"; } | |
std::string overload_rawbyptr(Klass *k) { return "rawbyptr"; } | |
std::string overload_rawbyptrref(int i) { return "int"; } | |
std::string overload_rawbyptrref(Klass *const&k) { return "rawbyptrref"; } | |
std::string overload_smartbyval(int i) { return "int"; } | |
std::string overload_smartbyval(SwigBoost::intrusive_ptr<Klass> k) { return "smartbyval"; } | |
std::string overload_smartbyref(int i) { return "int"; } | |
std::string overload_smartbyref(SwigBoost::intrusive_ptr<Klass> &k) { return "smartbyref"; } | |
std::string overload_smartbyptr(int i) { return "int"; } | |
std::string overload_smartbyptr(SwigBoost::intrusive_ptr<Klass> *k) { return "smartbyptr"; } | |
std::string overload_smartbyptrref(int i) { return "int"; } | |
std::string overload_smartbyptrref(SwigBoost::intrusive_ptr<Klass> *&k) { return "smartbyptrref"; } | |
} // namespace Space | |
%} | |
%{ | |
boost::detail::atomic_count Space::Klass::total_count(0); | |
boost::detail::atomic_count Space::KlassWithoutRefCount::total_count(0); | |
boost::detail::atomic_count Space::IgnoredRefCountingBase::total_count(0); | |
boost::detail::atomic_count Space::KlassDerived::total_count(0); | |
boost::detail::atomic_count Space::KlassDerivedDerived::total_count(0); | |
%} | |
// Member variables | |
%inline %{ | |
struct MemberVariables { | |
MemberVariables() : SmartMemberPointer(new SwigBoost::intrusive_ptr<Space::Klass>()), SmartMemberReference(*(new SwigBoost::intrusive_ptr<Space::Klass>())), MemberPointer(0), MemberReference(MemberValue) {} | |
virtual ~MemberVariables() { | |
delete SmartMemberPointer; | |
delete &SmartMemberReference; | |
} | |
SwigBoost::intrusive_ptr<Space::Klass> SmartMemberValue; | |
SwigBoost::intrusive_ptr<Space::Klass> * SmartMemberPointer; | |
SwigBoost::intrusive_ptr<Space::Klass> & SmartMemberReference; | |
Space::Klass MemberValue; | |
Space::Klass * MemberPointer; | |
Space::Klass & MemberReference; | |
}; | |
// Global variables | |
SwigBoost::intrusive_ptr<Space::Klass> GlobalSmartValue; | |
Space::Klass GlobalValue; | |
Space::Klass * GlobalPointer = 0; | |
Space::Klass & GlobalReference = GlobalValue; | |
%} | |
#if defined(INTRUSIVE_PTR_WRAPPERS_IMPLEMENTED) | |
// Note: %template after the intrusive_ptr typemaps | |
%intrusive_ptr(Base<int, double>) | |
%intrusive_ptr(Pair<int, double>) | |
#endif | |
// Templates | |
%inline %{ | |
template <class T1, class T2> struct Base { | |
Space::Klass klassBase; | |
T1 baseVal1; | |
T2 baseVal2; | |
Base(T1 t1, T2 t2) : baseVal1(t1*2), baseVal2(t2*2) {} | |
virtual std::string getValue() const { return "Base<>"; }; | |
mutable int count; | |
void addref(void) const { count++; } | |
void release(void) const { if (--count == 0) delete this; } | |
int use_count(void) const { return count; } | |
}; | |
%} | |
%template(BaseIntDouble) Base<int, double>; | |
%inline %{ | |
template <class T1, class T2> struct Pair : Base<T1, T2> { | |
Space::Klass klassPair; | |
T1 val1; | |
T2 val2; | |
Pair(T1 t1, T2 t2) : Base<T1, T2>(t1, t2), val1(t1), val2(t2) {} | |
virtual std::string getValue() const { return "Pair<>"; }; | |
}; | |
Pair<int, double> pair_id2(Pair<int, double> p) { return p; } | |
SwigBoost::intrusive_ptr< Pair<int, double> > pair_id1(SwigBoost::intrusive_ptr< Pair<int, double> > p) { return p; } | |
template<typename T> void intrusive_ptr_add_ref(const T* r) { r->addref(); } | |
template<typename T> void intrusive_ptr_release(const T* r) { r->release(); } | |
long use_count(const SwigBoost::shared_ptr<Space::Klass>& sptr) { | |
return sptr.use_count(); | |
} | |
long use_count(const SwigBoost::shared_ptr<Space::KlassDerived>& sptr) { | |
return sptr.use_count(); | |
} | |
long use_count(const SwigBoost::shared_ptr<Space::KlassDerivedDerived>& sptr) { | |
return sptr.use_count(); | |
} | |
%} | |
%template(PairIntDouble) Pair<int, double>; | |
// For counting the instances of intrusive_ptr (all of which are created on the heap) | |
// intrusive_ptr_wrapper_count() gives overall count | |
%inline %{ | |
namespace SwigBoost { | |
const int NOT_COUNTING = -123456; | |
int intrusive_ptr_wrapper_count() { | |
#ifdef INTRUSIVE_PTR_WRAPPER | |
return SwigBoost::IntrusivePtrWrapper::getTotalCount(); | |
#else | |
return NOT_COUNTING; | |
#endif | |
} | |
#ifdef INTRUSIVE_PTR_WRAPPER | |
template<> std::string show_message(boost::intrusive_ptr<Space::Klass >*t) { | |
if (!t) | |
return "null intrusive_ptr!!!"; | |
if (*t) | |
return "Klass: " + (*t)->getValue(); | |
else | |
return "Klass: NULL"; | |
} | |
template<> std::string show_message(boost::intrusive_ptr<const Space::Klass >*t) { | |
if (!t) | |
return "null intrusive_ptr!!!"; | |
if (*t) | |
return "Klass: " + (*t)->getValue(); | |
else | |
return "Klass: NULL"; | |
} | |
template<> std::string show_message(boost::intrusive_ptr<Space::KlassDerived >*t) { | |
if (!t) | |
return "null intrusive_ptr!!!"; | |
if (*t) | |
return "KlassDerived: " + (*t)->getValue(); | |
else | |
return "KlassDerived: NULL"; | |
} | |
template<> std::string show_message(boost::intrusive_ptr<const Space::KlassDerived >*t) { | |
if (!t) | |
return "null intrusive_ptr!!!"; | |
if (*t) | |
return "KlassDerived: " + (*t)->getValue(); | |
else | |
return "KlassDerived: NULL"; | |
} | |
#endif | |
} | |
%} | |