X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fmoof%2Fstlplus%2Fsmart_ptr.tpp;fp=src%2Fmoof%2Fstlplus%2Fsmart_ptr.tpp;h=0000000000000000000000000000000000000000;hb=6b0a0d0efafe34d48ab344fca3b479553bd4e62c;hp=cb1b8bbb825886754779bebcf2aabcc0980a793a;hpb=85783316365181491a3e3c0c63659972477cebba;p=chaz%2Fyoink

diff --git a/src/moof/stlplus/smart_ptr.tpp b/src/moof/stlplus/smart_ptr.tpp
deleted file mode 100755
index cb1b8bb..0000000
--- a/src/moof/stlplus/smart_ptr.tpp
+++ /dev/null
@@ -1,343 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-
-//   Author:    Andy Rushton
-//   Copyright: (c) Southampton University 1999-2004
-//              (c) Andy Rushton           2004-2009
-//   License:   BSD License, see ../docs/license.html
-
-////////////////////////////////////////////////////////////////////////////////
-
-namespace stlplus
-{
-
-  ////////////////////////////////////////////////////////////////////////////////
-  // internal holder data structure
-  ////////////////////////////////////////////////////////////////////////////////
-
-  template<typename T>
-  class smart_ptr_holder
-  {
-  private:
-    unsigned m_count;
-    T* m_data;
-
-    // make these private to disallow copying because the holder doesn't know how to copy
-    smart_ptr_holder(const smart_ptr_holder& s) :
-      m_count(0), m_data(0)
-      {
-      }
-
-    smart_ptr_holder& operator=(const smart_ptr_holder& s)
-      {
-        return *this;
-      }
-
-  public:
-    smart_ptr_holder(T* p = 0) : 
-      m_count(1), m_data(p)
-      {
-      }
-
-    ~smart_ptr_holder(void)
-      {
-        clear();
-      }
-
-    unsigned count(void) const
-      {
-        return m_count;
-      }
-
-    void increment(void)
-      {
-        ++m_count;
-      }
-
-    bool decrement(void)
-      {
-        --m_count;
-        return m_count == 0;
-      }
-
-    bool null(void)
-      {
-        return m_data == 0;
-      }
-
-    void clear(void)
-      {
-        if(m_data)
-          delete m_data;
-        m_data = 0;
-      }
-
-    void set(T* p = 0)
-      {
-        clear();
-        m_data = p;
-      }
-
-    T*& pointer(void)
-      {
-        return m_data;
-      }
-
-    const T* pointer(void) const
-      {
-        return m_data;
-      }
-
-    T& value(void)
-      {
-        return *m_data;
-      }
-
-    const T& value(void) const
-      {
-        return *m_data;
-      }
-  };
-
-  ////////////////////////////////////////////////////////////////////////////////
-  // smart_ptr_base class
-  ////////////////////////////////////////////////////////////////////////////////
-
-  ////////////////////////////////////////////////////////////////////////////////
-  // constructors, assignments and destructors
-
-  // create a null pointer
-  template <typename T, typename C>
-  smart_ptr_base<T,C>::smart_ptr_base(void) :
-    m_holder(new smart_ptr_holder<T>)
-  {
-  }
-
-  // create a pointer containing a *copy* of the object pointer
-  template <typename T, typename C>
-  smart_ptr_base<T,C>::smart_ptr_base(const T& data) throw(illegal_copy) :
-    m_holder(new smart_ptr_holder<T>)
-  {
-    m_holder->set(C()(data));
-  }
-
-  // create a pointer containing a dynamically created object
-  // Note: the object must be allocated *by the user* with new
-  // constructor form - must be called in the form smart_ptr<type> x(new type(args))
-  template <typename T, typename C>
-  smart_ptr_base<T,C>::smart_ptr_base(T* data) :
-    m_holder(new smart_ptr_holder<T>)
-  {
-    m_holder->set(data);
-  }
-
-  // copy constructor implements counted referencing - no copy is made
-  template <typename T, typename C>
-  smart_ptr_base<T,C>::smart_ptr_base(const smart_ptr_base<T,C>& r) :
-    m_holder(0)
-  {
-    m_holder = r.m_holder;
-    m_holder->increment();
-  }
-
-  // destructor decrements the reference count and delete only when the last reference is destroyed
-  template <typename T, typename C>
-  smart_ptr_base<T,C>::~smart_ptr_base(void)
-  {
-    if(m_holder->decrement())
-      delete m_holder;
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-  // logical tests to see if there is anything contained in the pointer since it can be null
-
-  template <typename T, typename C>
-  bool smart_ptr_base<T,C>::null(void) const
-  {
-    return m_holder->null();
-  }
-
-  template <typename T, typename C>
-  bool smart_ptr_base<T,C>::present(void) const
-  {
-    return !m_holder->null();
-  }
-
-  template <typename T, typename C>
-  bool smart_ptr_base<T,C>::operator!(void) const
-  {
-    return m_holder->null();
-  }
-
-  template <typename T, typename C>
-  smart_ptr_base<T,C>::operator bool(void) const
-  {
-    return !m_holder->null();
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-  // dereference operators and functions
-
-  template <typename T, typename C>
-  T& smart_ptr_base<T,C>::operator*(void) throw(null_dereference)
-  {
-    if (m_holder->null()) throw null_dereference("null pointer dereferenced in smart_ptr::operator*");
-    return m_holder->value();
-  }
-
-  template <typename T, typename C>
-  const T& smart_ptr_base<T,C>::operator*(void) const throw(null_dereference)
-  {
-    if (m_holder->null()) throw null_dereference("null pointer dereferenced in smart_ptr::operator*");
-    return m_holder->value();
-  }
-
-  template <typename T, typename C>
-  T* smart_ptr_base<T,C>::operator->(void) throw(null_dereference)
-  {
-    if (m_holder->null()) throw null_dereference("null pointer dereferenced in smart_ptr::operator->");
-    return m_holder->pointer();
-  }
-
-  template <typename T, typename C>
-  const T* smart_ptr_base<T,C>::operator->(void) const throw(null_dereference)
-  {
-    if (m_holder->null()) throw null_dereference("null pointer dereferenced in smart_ptr::operator->");
-    return m_holder->pointer();
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-  // explicit function forms of the above assignment dereference operators
-
-  template <typename T, typename C>
-  void smart_ptr_base<T,C>::set_value(const T& data) throw(illegal_copy)
-  {
-    m_holder->set(C()(data));
-  }
-
-  template <typename T, typename C>
-  T& smart_ptr_base<T,C>::value(void) throw(null_dereference)
-  {
-    if (m_holder->null()) throw null_dereference("null pointer dereferenced in smart_ptr::value");
-    return m_holder->value();
-  }
-
-  template <typename T, typename C>
-  const T& smart_ptr_base<T,C>::value(void) const throw(null_dereference)
-  {
-    if (m_holder->null()) throw null_dereference("null pointer dereferenced in smart_ptr::value");
-    return m_holder->value();
-  }
-
-  template <typename T, typename C>
-  void smart_ptr_base<T,C>::set(T* data)
-  {
-    m_holder->set(data);
-  }
-
-  template <typename T, typename C>
-  T* smart_ptr_base<T,C>::pointer(void)
-  {
-    return m_holder->pointer();
-  }
-
-  template <typename T, typename C>
-  const T* smart_ptr_base<T,C>::pointer(void) const
-  {
-    return m_holder->pointer();
-  }
-
-  ////////////////////////////////////////////////////////////////////////////////
-  // functions to manage counted referencing
-
-  // make this an alias of the passed object
-  template <typename T, typename C>
-  void smart_ptr_base<T,C>::alias(const smart_ptr_base<T,C>& r)
-  {
-    // make it alias-copy safe - this means that I don't try to do the
-    // assignment if r is either the same object or an alias of it
-    //   if (m_holder == r.m_holder) return;
-    //   if (m_holder->decrement())
-    //     delete m_holder;
-    //   m_holder = r.m_holder;
-    //   m_holder->increment();
-    make_alias(r.m_holder);
-  }
-
-  template <typename T, typename C>
-  bool smart_ptr_base<T,C>::aliases(const smart_ptr_base<T,C>& r) const
-  {
-    return m_holder == r.m_holder;
-  }
-
-  template <typename T, typename C>
-  unsigned smart_ptr_base<T,C>::alias_count(void) const
-  {
-    return m_holder->count();
-  }
-
-  template <typename T, typename C>
-  void smart_ptr_base<T,C>::clear(void)
-  {
-    m_holder->clear();
-  }
-
-  template <typename T, typename C>
-  void smart_ptr_base<T,C>::clear_unique(void)
-  {
-    if (m_holder->count() == 1)
-      m_holder->clear();
-    else
-    {
-      m_holder->decrement();
-      m_holder = 0;
-      m_holder = new smart_ptr_holder<T>;
-    }
-  }
-
-  template <typename T, typename C>
-  void smart_ptr_base<T,C>::make_unique(void) throw(illegal_copy)
-  {
-    if (m_holder->count() > 1)
-    {
-      smart_ptr_holder<T>* old_holder = m_holder;
-      m_holder->decrement();
-      m_holder = 0;
-      m_holder = new smart_ptr_holder<T>;
-      if (old_holder->pointer())
-        m_holder->set(C()(old_holder->value()));
-    }
-  }
-
-  template <typename T, typename C>
-  void smart_ptr_base<T,C>::copy(const smart_ptr_base<T,C>& data) throw(illegal_copy)
-  {
-    alias(data);
-    make_unique();
-  }
-
-  // internal function for distinguishing unique smart_ptr objects
-  // used for example in persistence routines
-
-  template <typename T, typename C>
-  void* smart_ptr_base<T,C>::handle(void) const
-  {
-    return m_holder;
-  }
-
-  template <typename T, typename C>
-  void smart_ptr_base<T,C>::make_alias(void* handle)
-  {
-    smart_ptr_holder<T>* r_holder = (smart_ptr_holder<T>*)handle;
-    if (m_holder != r_holder)
-    {
-      if (m_holder->decrement())
-        delete m_holder;
-      m_holder = r_holder;
-      m_holder->increment();
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////////////////
-
-} // end namespace stlplus
-