1 files changed, 498 insertions, 498 deletions
diff --git a/Examples/test-suite/li_boost_intrusive_ptr.i b/Examples/test-suite/li_boost_intrusive_ptr.i
index a122dc26e..2efa998a9 100644
--- a/Examples/test-suite/li_boost_intrusive_ptr.i
+++ b/Examples/test-suite/li_boost_intrusive_ptr.i
@@ -1,498 +1,498 @@
-// 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);
-%warnfilter(SWIGWARN_LANG_SMARTPTR_MISSING) KlassDerived;
-%warnfilter(SWIGWARN_LANG_SMARTPTR_MISSING) KlassDerivedDerived;
-
-%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)
-#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
-#if defined(SWIGJAVA)
-%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)"
-
-#elif defined(SWIGCSHARP)
-// TODO!
-#endif
-
-#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
-}
-%}
-
+// 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);
+%warnfilter(SWIGWARN_LANG_SMARTPTR_MISSING) KlassDerived;
+%warnfilter(SWIGWARN_LANG_SMARTPTR_MISSING) KlassDerivedDerived;
+
+%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)
+#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
+#if defined(SWIGJAVA)
+%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)"
+
+#elif defined(SWIGCSHARP)
+// TODO!
+#endif
+
+#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
+}
+%}
+