--- a/SConstruct	Mon Dec 18 11:39:48 2006 +0100
+++ b/SConstruct	Mon Dec 18 13:17:08 2006 +0100
@@ -18,6 +18,7 @@
 core.add_sources([
     'reference-list-test.cc',
     'callback-test.cc',
+    'ptr.cc',
     'test.cc'
     ])
 env = Environment()
@@ -37,6 +38,7 @@
     'system-wall-clock-ms.h',
     'reference-list.h',
     'callback.h',
+    'ptr.h',
     'test.h'
     ])
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/core/ptr.cc	Mon Dec 18 13:17:08 2006 +0100
@@ -0,0 +1,103 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2005,2006 INRIA
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation;
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
+ */
+#include "ptr.h"
+
+#ifdef RUN_SELF_TESTS
+
+#include "test.h"
+#include "callback.h"
+
+namespace ns3 {
+
+class NoCount
+{
+public:
+  NoCount (Callback<void> cb);
+  ~NoCount ();
+private:
+  Callback<void> m_cb;
+};
+NoCount::NoCount (Callback<void> cb)
+  : m_cb (cb)
+{}
+NoCount::~NoCount ()
+{
+  m_cb ();
+}
+
+class PtrTest : Test
+{
+public:
+  PtrTest ();
+  virtual ~PtrTest ();
+  virtual bool RunTests (void);
+private:
+  void DestroyNotify (void);
+  bool m_destroyed;
+};
+
+PtrTest::PtrTest ()
+  : Test ("Ptr")
+{}
+
+PtrTest::~PtrTest ()
+{}
+
+void 
+PtrTest::DestroyNotify (void)
+{
+  m_destroyed = true;
+}
+
+
+bool
+PtrTest::RunTests (void)
+{
+  bool ok = true;
+
+  Callback<void> cb = MakeCallback (&PtrTest::DestroyNotify, this);
+  m_destroyed = false;
+  {
+    Ptr<NoCount> p = new NoCount (cb);
+  }
+  if (!m_destroyed)
+    {
+      ok = false;
+    }
+  m_destroyed = false;
+  {
+    Ptr<NoCount> p;
+    p = new NoCount (cb);
+  }
+  if (!m_destroyed)
+    {
+      ok = false;
+    }
+  
+
+  return ok;
+}
+
+PtrTest g_ptr_test;
+
+}; // namespace ns3
+
+#endif /* RUN_SELF_TESTS */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/core/ptr.h	Mon Dec 18 13:17:08 2006 +0100
@@ -0,0 +1,270 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2005,2006 INRIA
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation;
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
+ */
+
+#ifndef PTR_H
+#define PTR_H
+
+#include <stdint.h>
+#include <cassert>
+
+namespace ns3 {
+
+/**
+ * \brief smart pointer class similar to boost::shared_ptr
+ *
+ * This smart-pointer class is supposed to be used to manage
+ * heap-allocated objects: when it decides it does not need
+ * the object it references, it invokes operator delete on it.
+ * This implementation allows you to manipulate the smart pointer
+ * as if it was a normal pointer: you can compare it with zero,
+ * compare it against other pointers, etc. However, the only 
+ * operation we are careful to avoid is the conversion back to
+ * raw pointers: if you need to convert back, you need to invoke
+ * the Ptr<T>::Remove method which returns a raw pointer and
+ * makes the smart pointer forget about the raw pointer.
+ */
+template <typename T>
+class Ptr 
+{
+private:
+  T *m_ptr;
+  uint32_t *m_count;
+  class Tester {
+  private:
+    void operator delete (void *);
+  };
+  static uint32_t *AllocCount (void);
+  static void DeallocCount (uint32_t *count);
+public:
+  /**
+   * Create an empty smart pointer
+   */
+  Ptr ();
+  /**
+   * \param ptr raw pointer to manage
+   *
+   * Create a smart pointer which points to the
+   * input raw pointer. This method takes ownershipt
+   * of the input raw pointer. That is, the smart pointer
+   * becomes responsible for calling delete on the
+   * raw pointer when needed.
+   */
+  Ptr (T *ptr);
+  Ptr (Ptr const&o);
+  // allow conversions from T to T const.
+  template <typename U>
+  Ptr (Ptr<U> const &o);
+  ~Ptr () ;
+  Ptr<T> &operator = (Ptr const& o);
+  T *operator -> () const;
+  T *operator -> ();
+  // allow if (!sp)
+  bool operator! ();
+  // allow if (sp)
+  operator Tester * () const;
+  // allow if (sp == 0)
+  template <typename T1, typename T2>
+  inline friend bool operator == (Ptr<T1> const &lhs, T2 const *rhs);
+  // allow if (0 == sp)
+  template <typename T1, typename T2>
+  inline friend bool operator == (T1 const *lhs, Ptr<T2> &rhs);
+  // allow if (sp != 0)
+  template <typename T1, typename T2>
+  inline friend bool operator != (Ptr<T1> const &lhs, T2 const *rhs);
+  // allow if (0 != sp)
+  template <typename T1, typename T2>
+  inline friend bool operator != (T1 const *lhs, Ptr<T2> &rhs);
+
+  /**
+   * \returns raw pointer
+   *
+   * It is a programming error to invoke this method when
+   * the reference count of the smart pointer is not one.
+   * If you try to do it anyway, an assert will be triggered.
+   * If asserts are disabled, bad things will happen.
+   * Once you have successfully called Ptr<T>::Remove on
+   * a smart pointer, the smart pointer will forget 
+   * about the raw pointer and will stop managing it. As such,
+   * you, as the caller, become responsible for invoking
+   * operator delete on the returned raw pointer.
+   */
+  T *Remove (void);
+};
+
+template <typename T>
+uint32_t *
+Ptr<T>::AllocCount (void)
+{
+  return new uint32_t [1] ();
+}
+template <typename T>
+void 
+Ptr<T>::DeallocCount (uint32_t *count)
+{
+  delete [] count;
+}
+
+template <typename T>
+Ptr<T>::Ptr ()
+  : m_ptr (0),
+    m_count (Ptr::AllocCount ())
+{}
+
+template <typename T>
+Ptr<T>::Ptr (T *ptr) 
+  : m_ptr (ptr),
+    m_count (Ptr::AllocCount ())
+{
+  if (m_ptr != 0)
+    {
+      *m_count = 1;
+    }
+}
+
+template <typename T>
+Ptr<T>::Ptr (Ptr const&o) 
+  : m_ptr (o.m_ptr),
+    m_count (o.m_count)
+{
+  if (m_ptr != 0) 
+    {
+      (*m_count)++;
+    }
+}
+template <typename T>
+template <typename U>
+Ptr<T>::Ptr (Ptr<U> const &o)
+  : m_ptr (o.m_ptr),
+    m_count (o.m_count)
+{
+  if (m_ptr != 0) 
+    {
+      (*m_count)++;
+    }
+}
+
+template <typename T>
+Ptr<T>::~Ptr () 
+{
+  if (m_ptr != 0) 
+    {
+      (*m_count)--;
+      if ((*m_count) == 0) 
+        {
+          delete m_ptr;
+          Ptr::DeallocCount (m_count);
+        }
+    }
+}
+
+template <typename T>
+Ptr<T> &
+Ptr<T>::operator = (Ptr const& o) 
+{
+  if (o.m_ptr != 0) 
+    {
+      (*(o.m_count))++;
+    }
+  if (m_ptr != 0) 
+    {
+      (*m_count)--;
+      if ((*m_count) == 0) 
+        {
+          delete m_ptr;
+          Ptr::DeallocCount (m_count);
+        }
+    }
+  m_ptr = o.m_ptr;
+  m_count = o.m_count;
+  return *this;
+}
+
+template <typename T>
+T *
+Ptr<T>::operator -> () 
+{
+  return m_ptr;
+}
+
+template <typename T>
+T *
+Ptr<T>::operator -> () const
+{
+  return m_ptr;
+}
+
+template <typename T>
+bool 
+Ptr<T>::operator! () 
+{
+  return m_ptr == 0;
+}
+
+template <typename T>
+Ptr<T>::operator Tester * () const
+{
+  if (m_ptr == 0) 
+    {
+      return 0;
+    }
+  static Tester test;
+  return &test;
+}
+
+template <typename T>
+T *
+Ptr<T>::Remove (void) 
+{
+  assert (m_ptr.m_count == 1);
+  T *retval = m_ptr;
+  m_ptr = 0;
+  return retval;
+}
+
+// non-member friend functions.
+template <typename T1, typename T2>
+bool 
+operator == (Ptr<T1> const &lhs, T2 const *rhs)
+{
+  return lhs.m_ptr == rhs;
+}
+template <typename T1, typename T2>
+bool 
+operator == (T1 const *lhs, Ptr<T2> &rhs)
+{
+  return lhs == rhs.m_ptr;
+}
+template <typename T1, typename T2>
+bool 
+operator != (Ptr<T1> const &lhs, T2 const *rhs)
+{
+  return lhs.m_ptr != rhs;
+}
+template <typename T1, typename T2>
+bool 
+operator != (T1 const *lhs, Ptr<T2> &rhs)
+{
+  return lhs != rhs.m_ptr;
+}
+
+}; // namespace ns3
+
+#endif /* PTR_H */